From 9022e16e42c8f911bed88e3930a934be60875645 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 10 Aug 2026 23:16:04 +0000
Subject: [PATCH 01/20] build(deps-dev): bump js-yaml from 4.3.0 to 4.3.1

Bumps [js-yaml](https://github.com/nodeca/js-yaml) from 4.3.0 to 4.3.1.
- [Changelog](https://github.com/nodeca/js-yaml/blob/4.3.1/CHANGELOG.md)
- [Commits](https://github.com/nodeca/js-yaml/compare/4.3.0...4.3.1)

---
updated-dependencies:
- dependency-name: js-yaml
  dependency-version: 4.3.1
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package.json   |  2 +-
 pnpm-lock.yaml | 20 ++++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/package.json b/package.json
index a8d183446..845226440 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,7 @@
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
     "@types/node": "^22.13.14",
-    "js-yaml": "^4.1.0",
+    "js-yaml": "^4.3.1",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b6bb3277c..f3c8fb98a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -30,8 +30,8 @@ importers:
         specifier: ^22.13.14
         version: 22.20.0
       js-yaml:
-        specifier: ^4.1.0
-        version: 4.3.0
+        specifier: ^4.3.1
+        version: 4.3.1
       tsup:
         specifier: ^8.5.0
         version: 8.5.1(postcss@8.5.16)(typescript@5.9.3)
@@ -876,12 +876,12 @@ packages:
   js-tokens@9.0.1:
     resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
 
-  js-yaml@3.15.0:
-    resolution: {integrity: sha512-ttBQIIQPDeLjpPOohtUdXuXUVoA2uIB6fEH9HyJ7234s5mBJ5wTx20njxplLZQgLaOfpmPQA7X2t5AX6tIPbog==}
+  js-yaml@3.15.1:
+    resolution: {integrity: sha512-S99WuO3HlhO3XN41EtYUNl9zzXjoJx7QvmipxsJVxtCBT0YHEFy+iOJhjSvrmV12nYhWpZaM8lPHkJm0yUMbag==}
     hasBin: true
 
-  js-yaml@4.3.0:
-    resolution: {integrity: sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==}
+  js-yaml@4.3.1:
+    resolution: {integrity: sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ==}
     hasBin: true
 
   jsonfile@4.0.0:
@@ -1401,7 +1401,7 @@ snapshots:
   '@changesets/parse@0.4.3':
     dependencies:
       '@changesets/types': 6.1.0
-      js-yaml: 4.3.0
+      js-yaml: 4.3.1
 
   '@changesets/pre@2.0.2':
     dependencies:
@@ -2010,12 +2010,12 @@ snapshots:
 
   js-tokens@9.0.1: {}
 
-  js-yaml@3.15.0:
+  js-yaml@3.15.1:
     dependencies:
       argparse: 1.0.10
       esprima: 4.0.1
 
-  js-yaml@4.3.0:
+  js-yaml@4.3.1:
     dependencies:
       argparse: 2.0.1
 
@@ -2138,7 +2138,7 @@ snapshots:
   read-yaml-file@1.1.0:
     dependencies:
       graceful-fs: 4.2.11
-      js-yaml: 3.15.0
+      js-yaml: 3.15.1
       pify: 4.0.1
       strip-bom: 3.0.0
 

From 142f41d88319b5dff7155ca57db7259f012f29b9 Mon Sep 17 00:00:00 2001
From: James Sadler <james@cipherstash.com>
Date: Mon, 17 Aug 2026 10:33:43 +1000
Subject: [PATCH 02/20] fix(json): restore deprecated ste_vec_contains aliases

---
 .changeset/rename-ste-vec-contains.md         | 10 +++---
 src/v3/json/functions.sql                     | 32 +++++++++++++++++++
 tasks/docs/doxygen-filter.sh                  | 22 ++++++++++---
 tasks/test/docs_v3_grep.sh                    | 13 +++++++-
 .../sqlx/snapshots/eql_v3_public_surface.txt  |  2 ++
 tests/sqlx/tests/v3_jsonb_tests.rs            | 23 +++++++++++++
 6 files changed, 93 insertions(+), 9 deletions(-)

diff --git a/.changeset/rename-ste-vec-contains.md b/.changeset/rename-ste-vec-contains.md
index 4585af313..1b1b25c53 100644
--- a/.changeset/rename-ste-vec-contains.md
+++ b/.changeset/rename-ste-vec-contains.md
@@ -1,10 +1,12 @@
 ---
-'@cipherstash/eql': major
+'@cipherstash/eql': patch
 ---
 
 **`eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`.** This
 consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family,
 matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`,
-`jsonb_query`). The function backs the `json` `@>` / `<@` containment operators;
-its behaviour is unchanged. Callers that invoke the function by name (Supabase /
-PostgREST, which call functions rather than operators) must update the name.
+`jsonb_query`). The old name remains available as a deprecated compatibility
+alias, so existing direct callers continue to work; new code should use
+`jsonb_document_contains`. The `json` `@>` / `<@` containment operators and the
+raw-jsonb function-form entry points, `eql_v3.jsonb_contains(jsonb, jsonb)` and
+`eql_v3.jsonb_contained_by(jsonb, jsonb)`, are unchanged.
diff --git a/src/v3/json/functions.sql b/src/v3/json/functions.sql
index e5770dde7..fa8acdc2f 100644
--- a/src/v3/json/functions.sql
+++ b/src/v3/json/functions.sql
@@ -349,6 +349,38 @@ AS $$
        @> eql_v3.to_ste_vec_query(b)::jsonb
 $$;
 
+--! @cond deprecated_compatibility
+--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).
+--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).
+--! @param a jsonb[] sv array to search within.
+--! @param b jsonb sv element to search for.
+--! @return boolean True if b's selector is present in any element of a.
+CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)
+  RETURNS boolean
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$
+  SELECT eql_v3.jsonb_document_contains(a, b)
+$$;
+
+COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS
+  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';
+
+--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).
+--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).
+--! @param a public.eql_v3_json_search Container.
+--! @param b public.eql_v3_json_search Elements to find.
+--! @return boolean True if all elements of b are contained in a.
+CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)
+  RETURNS boolean
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$
+  SELECT eql_v3.jsonb_document_contains(a, b)
+$$;
+
+COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS
+  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';
+--! @endcond
+
 ------------------------------------------------------------------------------
 -- Path queries (text selector only)
 ------------------------------------------------------------------------------
diff --git a/tasks/docs/doxygen-filter.sh b/tasks/docs/doxygen-filter.sh
index 0b5313bdb..fe00c19ab 100755
--- a/tasks/docs/doxygen-filter.sh
+++ b/tasks/docs/doxygen-filter.sh
@@ -10,10 +10,13 @@ if [ "$#" -ne 1 ]; then
   exit 2
 fi
 
-# Prepares SQL for Doxygen's C++ parser. Three transforms:
+# Prepares SQL for Doxygen's C++ parser. Four transforms:
 #
-#  1. `--!` doc comments -> `//!` so Doxygen sees them.
-#  2. Strip dollar-quoted function bodies (`$$ ... $$`), leaving just the
+#  1. Omit blocks marked `@cond deprecated_compatibility`. These functions
+#     remain callable for backwards compatibility but must not appear in the
+#     generated function reference or source browser.
+#  2. `--!` doc comments -> `//!` so Doxygen sees them.
+#  3. Strip dollar-quoted function bodies (`$$ ... $$`), leaving just the
 #     declaration and its trailing clauses. Doxygen parses SQL heuristically as
 #     C++, and body SQL derails it: a `::type` cast reads as C++ scope
 #     resolution and drops the whole enclosing CREATE FUNCTION memberdef (this
@@ -23,7 +26,7 @@ fi
 #     documentation, so removing them is lossless for the generated reference
 #     and leaves Doxygen only clean `CREATE FUNCTION name(args) RETURNS ...`
 #     declarations to read. Only bare `$$` quoting is used in this codebase.
-#  3. Strip CREATE AGGREGATE definition bodies, for the same reason and with the
+#  4. Strip CREATE AGGREGATE definition bodies, for the same reason and with the
 #     same losslessness: `sfunc`/`stype`/`combinefunc`/`parallel` carry no
 #     documentation. The trailing `( ... )` is a SECOND parenthesised group
 #     after the signature, and C++ has no such form, so Doxygen misreads the
@@ -39,6 +42,17 @@ fi
 #     Reducing each to a single `CREATE AGGREGATE name(argtype);` declaration
 #     recovers the name in both cases and leaves a clean argument list.
 awk '
+  /^--![[:space:]]+@cond[[:space:]]+deprecated_compatibility[[:space:]]*$/ {
+    inhidden = 1
+    print ""
+    next
+  }
+  inhidden && /^--![[:space:]]+@endcond[[:space:]]*$/ {
+    inhidden = 0
+    print ""
+    next
+  }
+  inhidden { print ""; next }
   /^--!/ { print "//!" substr($0, 4); next }
   # Emit the signature up to its balanced closing paren, then skip the body.
   !inagg && /^[[:space:]]*CREATE[[:space:]]+AGGREGATE/ {
diff --git a/tasks/test/docs_v3_grep.sh b/tasks/test/docs_v3_grep.sh
index 8eeff97a3..fdd6ba0a0 100755
--- a/tasks/test/docs_v3_grep.sh
+++ b/tasks/test/docs_v3_grep.sh
@@ -62,8 +62,19 @@ for f in "${DOC_FILES[@]}"; do
   fi
 done
 
+# Deprecated SQL compatibility aliases remain installed, but the explicitly
+# hidden block must never reach Doxygen — including its generated source browser.
+ste_vec_alias_count=$(grep -c '^CREATE FUNCTION eql_v3\.ste_vec_contains' src/v3/json/functions.sql || true)
+if [ "$ste_vec_alias_count" -ne 2 ]; then
+  echo "FAIL: expected both deprecated ste_vec_contains overloads in src/v3/json/functions.sql" >&2
+  status=1
+elif tasks/docs/doxygen-filter.sh src/v3/json/functions.sql | grep -q 'ste_vec_contains'; then
+  echo "FAIL: deprecated ste_vec_contains aliases leaked through the Doxygen input filter" >&2
+  status=1
+fi
+
 if [ "$status" -eq 0 ]; then
-  echo "OK: no user-facing doc references eql_v2 (${#DOC_FILES[@]} files scanned)."
+  echo "OK: user-facing docs contain neither eql_v2 nor the hidden ste_vec_contains alias (${#DOC_FILES[@]} files scanned)."
 else
   echo >&2
   echo "The eql_v2 surface was removed in 3.0.0; user-facing docs must teach only eql_v3." >&2
diff --git a/tests/sqlx/snapshots/eql_v3_public_surface.txt b/tests/sqlx/snapshots/eql_v3_public_surface.txt
index 1f7ace6ed..85c9bfaf6 100644
--- a/tests/sqlx/snapshots/eql_v3_public_surface.txt
+++ b/tests/sqlx/snapshots/eql_v3_public_surface.txt
@@ -1272,6 +1272,8 @@ function eql_v3.ord_term_ore(a public.eql_v3_timestamp_ord_ore)
 function eql_v3.selector(entry public.eql_v3_json_entry)
 function eql_v3.selector(val jsonb)
 function eql_v3.ste_vec(val jsonb)
+function eql_v3.ste_vec_contains(a jsonb[], b jsonb)
+function eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)
 function eql_v3.to_ste_vec_query(e eql_v3.query_json)
 function eql_v3.to_ste_vec_query(e public.eql_v3_json_search)
 function eql_v3.version()
diff --git a/tests/sqlx/tests/v3_jsonb_tests.rs b/tests/sqlx/tests/v3_jsonb_tests.rs
index 97741b4e2..2eab32842 100644
--- a/tests/sqlx/tests/v3_jsonb_tests.rs
+++ b/tests/sqlx/tests/v3_jsonb_tests.rs
@@ -577,6 +577,29 @@ async fn v3_jsonb_raw_helpers_contains_and_contained_by(pool: PgPool) -> anyhow:
         "jsonb_contains must agree with the typed @> operator"
     );
 
+    let legacy_raw: bool = sqlx::query_scalar(&format!(
+        "SELECT eql_v3.ste_vec_contains(\
+           eql_v3.jsonb_array('{full}'::jsonb), \
+           (eql_v3.jsonb_array('{subset}'::jsonb))[1])"
+    ))
+    .fetch_one(&pool)
+    .await?;
+    let legacy_typed: bool = sqlx::query_scalar(&format!(
+        "SELECT eql_v3.ste_vec_contains(\
+           '{full}'::public.eql_v3_json_search, \
+           '{subset}'::public.eql_v3_json_search)"
+    ))
+    .fetch_one(&pool)
+    .await?;
+    assert!(
+        legacy_raw,
+        "legacy raw ste_vec_contains alias must remain callable"
+    );
+    assert_eq!(
+        legacy_typed, typed,
+        "legacy typed ste_vec_contains alias must agree with jsonb containment"
+    );
+
     // Ordering terms are not equality terms. All containment entry points
     // normalize to selector-only matching, so two entries with the same value
     // selector match even when one carries a different `op`.

From 600a9b2d6daa8a7493c8723dfb22dbe2cf97f285 Mon Sep 17 00:00:00 2001
From: James Sadler <james@cipherstash.com>
Date: Mon, 17 Aug 2026 10:48:37 +1000
Subject: [PATCH 03/20] test(json): use encrypted fixture for legacy aliases

---
 tests/sqlx/tests/v3_jsonb_tests.rs | 53 +++++++++++++++++-------------
 1 file changed, 30 insertions(+), 23 deletions(-)

diff --git a/tests/sqlx/tests/v3_jsonb_tests.rs b/tests/sqlx/tests/v3_jsonb_tests.rs
index 2eab32842..de24ca55d 100644
--- a/tests/sqlx/tests/v3_jsonb_tests.rs
+++ b/tests/sqlx/tests/v3_jsonb_tests.rs
@@ -577,29 +577,6 @@ async fn v3_jsonb_raw_helpers_contains_and_contained_by(pool: PgPool) -> anyhow:
         "jsonb_contains must agree with the typed @> operator"
     );
 
-    let legacy_raw: bool = sqlx::query_scalar(&format!(
-        "SELECT eql_v3.ste_vec_contains(\
-           eql_v3.jsonb_array('{full}'::jsonb), \
-           (eql_v3.jsonb_array('{subset}'::jsonb))[1])"
-    ))
-    .fetch_one(&pool)
-    .await?;
-    let legacy_typed: bool = sqlx::query_scalar(&format!(
-        "SELECT eql_v3.ste_vec_contains(\
-           '{full}'::public.eql_v3_json_search, \
-           '{subset}'::public.eql_v3_json_search)"
-    ))
-    .fetch_one(&pool)
-    .await?;
-    assert!(
-        legacy_raw,
-        "legacy raw ste_vec_contains alias must remain callable"
-    );
-    assert_eq!(
-        legacy_typed, typed,
-        "legacy typed ste_vec_contains alias must agree with jsonb containment"
-    );
-
     // Ordering terms are not equality terms. All containment entry points
     // normalize to selector-only matching, so two entries with the same value
     // selector match even when one carries a different `op`.
@@ -625,6 +602,36 @@ async fn v3_jsonb_raw_helpers_contains_and_contained_by(pool: PgPool) -> anyhow:
     Ok(())
 }
 
+/// Both deprecated `ste_vec_contains` overloads remain callable over a real
+/// CipherStash-generated SteVec payload and agree with their replacement.
+#[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))]
+async fn v3_jsonb_legacy_ste_vec_contains_aliases(pool: PgPool) -> anyhow::Result<()> {
+    let (legacy_raw, current_raw, legacy_typed, current_typed): (bool, bool, bool, bool) =
+        sqlx::query_as(
+            "SELECT \
+               eql_v3.ste_vec_contains(\
+                 eql_v3.ste_vec(payload::jsonb), \
+                 (eql_v3.ste_vec(payload::jsonb))[1]), \
+               eql_v3.jsonb_document_contains(\
+                 eql_v3.ste_vec(payload::jsonb), \
+                 (eql_v3.ste_vec(payload::jsonb))[1]), \
+               eql_v3.ste_vec_contains(payload, payload), \
+               eql_v3.jsonb_document_contains(payload, payload) \
+             FROM fixtures.v3_ste_vec \
+             ORDER BY id \
+             LIMIT 1",
+        )
+        .fetch_one(&pool)
+        .await?;
+
+    assert!(legacy_raw, "legacy raw alias must find a real sv entry");
+    assert_eq!(legacy_raw, current_raw);
+    assert!(legacy_typed, "legacy typed alias must contain itself");
+    assert_eq!(legacy_typed, current_typed);
+
+    Ok(())
+}
+
 /// `eql_v3.ord_term(jsonb_entry)` has no `has_*` companion: absence of an
 /// `op` term is signalled by the extractor returning SQL NULL (which a
 /// functional btree index stores and comparisons skip). Dedicated

From 35bce9e55fca77f51a73095962f483f4321732d6 Mon Sep 17 00:00:00 2001
From: James Sadler <james@cipherstash.com>
Date: Mon, 17 Aug 2026 12:09:24 +1000
Subject: [PATCH 04/20] fix(ci): register restored alias coverage

---
 tasks/test/splinter.sh                  | 1 +
 tests/sqlx/snapshots/v3_jsonb_tests.txt | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tasks/test/splinter.sh b/tasks/test/splinter.sh
index af7c7e98a..058689892 100755
--- a/tasks/test/splinter.sh
+++ b/tasks/test/splinter.sh
@@ -103,6 +103,7 @@ function_search_path_mutable	eql_v3	selector	function	STE-vec entry selector ext
 function_search_path_mutable	eql_v3	ope_term	function	STE-vec ordered-term extractor for public.eql_v3_jsonb_entry: inlinable so `eql_v3.ope_term(col -> 'sel')` folds into the calling range query and matches the functional btree index built on the same expression. SET search_path would disable SQL function inlining. The deprecated eq_term(json_entry) compatibility alias is pinned and does not surface.
 function_search_path_mutable	eql_v3	to_ste_vec_query	function	Encrypted-JSONB query-document constructor (CAST WITH FUNCTION for eql_v3.query_jsonb): inlinable SQL over a public.eql_v3_json domain arg, structural domain-arg skip. Builds the ste_vec query value the @>/<@ wrappers compare against; must inline to fold into the calling query.
 function_search_path_mutable	eql_v3	jsonb_document_contains	function	Typed encrypted-JSONB document containment engine backing the public.eql_v3_json_search @>/<@ operators: the inlinable SQL (public.eql_v3_json_search) overload folds to native jsonb containment over eql_v3.to_ste_vec_query(a/b)::jsonb, so the planner can match the functional GIN index on eql_v3.to_ste_vec_query(col)::jsonb. Structural domain-arg skip leaves this overload unpinned; the raw jsonb[] plpgsql overload has a fixed search_path and does not surface.
+function_search_path_mutable	eql_v3	ste_vec_contains	function	Deprecated compatibility alias for the typed eql_v3.jsonb_document_contains overload. It must remain inlinable so existing function-form queries retain the same functional-GIN-index matching as before the rename. The public.eql_v3_json_search domain arguments leave this overload intentionally unpinned; the raw jsonb[] alias is pinned by tasks/pin_search_path_v3.sql and does not surface.
 function_search_path_mutable	eql_v3	jsonb_array	function	ste_vec deterministic-field array extractor on the eql_v3 encrypted-JSONB surface: public inlinable SQL (raw jsonb arg) behind the documented functional GIN index expression eql_v3.jsonb_array(col). Takes bare jsonb, so it carries the documented `eql-inline-critical` COMMENT marker that pin_search_path_v3.sql honours rather than the structural skip.
 function_search_path_mutable	eql_v3	jsonb_contains	function	Public GIN-inlining containment helper (function-form of @> over raw jsonb): unfolds to eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b). Carries the `eql-inline-critical` COMMENT marker.
 function_search_path_mutable	eql_v3	jsonb_contained_by	function	Public GIN-inlining reverse-containment helper (function-form of <@ over raw jsonb): same as eql_v3.jsonb_contains.
diff --git a/tests/sqlx/snapshots/v3_jsonb_tests.txt b/tests/sqlx/snapshots/v3_jsonb_tests.txt
index 3296365fa..729859b65 100644
--- a/tests/sqlx/snapshots/v3_jsonb_tests.txt
+++ b/tests/sqlx/snapshots/v3_jsonb_tests.txt
@@ -33,6 +33,7 @@ v3_jsonb_generator_envelope_shape_accepted
 v3_jsonb_index_ord_ope_btree_engages
 v3_jsonb_index_to_ste_vec_query_gin_engages
 v3_jsonb_json_payload_check
+v3_jsonb_legacy_ste_vec_contains_aliases
 v3_jsonb_minus_array_blocker
 v3_jsonb_minus_int_blocker
 v3_jsonb_minus_text_blocker

From c1057af0748266bd12a5f096f87ad24eeebae3ee Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Tue, 18 Aug 2026 09:10:46 +1000
Subject: [PATCH 05/20] fix(deps): patch postcss to 8.5.26

Signed-off-by: Toby Hede <toby@cipherstash.com>
---
 pnpm-lock.yaml | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f3c8fb98a..9f66fea6f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -34,7 +34,7 @@ importers:
         version: 4.3.1
       tsup:
         specifier: ^8.5.0
-        version: 8.5.1(postcss@8.5.16)(typescript@5.9.3)
+        version: 8.5.1(postcss@8.5.26)(typescript@5.9.3)
       typescript:
         specifier: ^5.8.3
         version: 5.9.3
@@ -49,7 +49,7 @@ importers:
         version: 22.20.0
       tsup:
         specifier: 'catalog:'
-        version: 8.5.1(postcss@8.5.16)(typescript@5.9.3)
+        version: 8.5.1(postcss@8.5.26)(typescript@5.9.3)
       typescript:
         specifier: 'catalog:'
         version: 5.9.3
@@ -932,8 +932,8 @@ packages:
   mz@2.7.0:
     resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
 
-  nanoid@3.3.15:
-    resolution: {integrity: sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==}
+  nanoid@3.3.18:
+    resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
@@ -1026,8 +1026,8 @@ packages:
       yaml:
         optional: true
 
-  postcss@8.5.16:
-    resolution: {integrity: sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==}
+  postcss@8.5.26:
+    resolution: {integrity: sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==}
     engines: {node: ^10 || ^12 || >=14}
 
   prettier@2.8.8:
@@ -2065,7 +2065,7 @@ snapshots:
       object-assign: 4.1.1
       thenify-all: 1.6.0
 
-  nanoid@3.3.15: {}
+  nanoid@3.3.18: {}
 
   object-assign@4.1.1: {}
 
@@ -2117,15 +2117,15 @@ snapshots:
       mlly: 1.8.2
       pathe: 2.0.3
 
-  postcss-load-config@6.0.1(postcss@8.5.16):
+  postcss-load-config@6.0.1(postcss@8.5.26):
     dependencies:
       lilconfig: 3.1.3
     optionalDependencies:
-      postcss: 8.5.16
+      postcss: 8.5.26
 
-  postcss@8.5.16:
+  postcss@8.5.26:
     dependencies:
-      nanoid: 3.3.15
+      nanoid: 3.3.18
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
@@ -2267,7 +2267,7 @@ snapshots:
 
   ts-interface-checker@0.1.13: {}
 
-  tsup@8.5.1(postcss@8.5.16)(typescript@5.9.3):
+  tsup@8.5.1(postcss@8.5.26)(typescript@5.9.3):
     dependencies:
       bundle-require: 5.1.0(esbuild@0.27.7)
       cac: 6.7.14
@@ -2278,7 +2278,7 @@ snapshots:
       fix-dts-default-cjs-exports: 1.0.1
       joycon: 3.1.1
       picocolors: 1.1.1
-      postcss-load-config: 6.0.1(postcss@8.5.16)
+      postcss-load-config: 6.0.1(postcss@8.5.26)
       resolve-from: 5.0.0
       rollup: 4.62.2
       source-map: 0.7.6
@@ -2287,7 +2287,7 @@ snapshots:
       tinyglobby: 0.2.17
       tree-kill: 1.2.2
     optionalDependencies:
-      postcss: 8.5.16
+      postcss: 8.5.26
       typescript: 5.9.3
     transitivePeerDependencies:
       - jiti
@@ -2329,7 +2329,7 @@ snapshots:
       esbuild: 0.28.1
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
-      postcss: 8.5.16
+      postcss: 8.5.26
       rollup: 4.62.2
       tinyglobby: 0.2.17
     optionalDependencies:

From 4b504830bd5aadda1de932d6752d0555dbad72b4 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Tue, 18 Aug 2026 14:19:25 +1000
Subject: [PATCH 06/20] fix(deps): bump jsonwebtoken to 10.4.0 via stack-auth
 0.42.2

Signed-off-by: Toby Hede <toby@cipherstash.com>
---
 Cargo.lock | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cc569499e..0bdbfe72f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -612,9 +612,9 @@ dependencies = [
 
 [[package]]
 name = "cipherstash-config"
-version = "0.42.0"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56cde3aaa5e2916a40530932f142c37ad6202835a6d221ce6c46fc14bfec8fc5"
+checksum = "b94efb31c4b6cc951f2ed2c2a953393ba34136c37c5ddd022a8da732f174e532"
 dependencies = [
  "bitflags",
  "serde",
@@ -872,9 +872,9 @@ dependencies = [
 
 [[package]]
 name = "cts-common"
-version = "0.42.0"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe2acdda527057d48061433ace5378d8452f10d6787f78e0e69b1cddacc57082"
+checksum = "576c82618990e693abe4dfbd06dada0bcb45884a4514405851eec6d82818f52c"
 dependencies = [
  "arrayvec",
  "base32",
@@ -2127,17 +2127,20 @@ dependencies = [
 
 [[package]]
 name = "jsonwebtoken"
-version = "9.3.1"
+version = "10.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde"
+checksum = "eba32bfb4ffdeaca3e34431072faf01745c9b26d25504aa7a6cf5684334fc4fc"
 dependencies = [
+ "aws-lc-rs",
  "base64",
+ "getrandom 0.2.16",
  "js-sys",
  "pem",
- "ring",
  "serde",
  "serde_json",
+ "signature",
  "simple_asn1",
+ "zeroize",
 ]
 
 [[package]]
@@ -3855,9 +3858,9 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "stack-auth"
-version = "0.42.0"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1c9c640571eba8fa5a705ccebe5c5e50aa27d4d51f4ec1614ffd1841b8a13a"
+checksum = "f1a9ac43060af7605899754daa3de2e26302c2ab4d9249a8bc16157bc53dad65"
 dependencies = [
  "aquamarine",
  "base64",
@@ -3883,9 +3886,9 @@ dependencies = [
 
 [[package]]
 name = "stack-profile"
-version = "0.42.0"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "192a90bfa46efe194c2b8beae5523f6214714574c7e8a210c78021259f100e79"
+checksum = "90ce7ca95d8e688a35e86e0682293a2085d9b1f26e7ca5b489009c6ee0c6967a"
 dependencies = [
  "dirs",
  "gethostname",
@@ -4882,7 +4885,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -5415,9 +5418,9 @@ dependencies = [
 
 [[package]]
 name = "zerokms-protocol"
-version = "0.12.26"
+version = "0.12.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16f731f2de99e66396928faef44b02b39288dc9a93f77a4a3e1dcdc33c1adad0"
+checksum = "29486723fdd2bdb0c234174dc242051a46ac0c82935ccaa39e9781dbf7bcc6d2"
 dependencies = [
  "base64",
  "cipherstash-config",

From 6ba124fbf54e27f672e03730eaea212cb5945643 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 08:28:39 +1000
Subject: [PATCH 07/20] fix(deps): keep winapi-util on windows-sys 0.61.2

The jsonwebtoken 10.4.0 bump re-resolved winapi-util's windows-sys
edge from 0.61.2 down to 0.48.0. winapi-util declares a permissive
range (>=0.48.0, <=0.61.*), so both satisfy it and cargo is free to
pick either; pin the lockfile back to 0.61.2.

Inert in practice - the edge is cfg(windows)-gated and CI is Ubuntu
only - but there is no reason to build against three-generation-older
bindings.

Signed-off-by: Toby Hede <toby@cipherstash.com>
---
 Cargo.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0bdbfe72f..a7619f5f8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4885,7 +4885,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]

From 4b2d8596c96a707b04a941aba6fcb251e658a7c7 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 18 Aug 2026 23:26:01 +0000
Subject: [PATCH 08/20] Version Packages

---
 .changeset/rename-ste-vec-contains.md         | 12 ------
 Cargo.lock                                    |  2 +-
 crates/eql-bindings/Cargo.toml                |  2 +-
 .../eql-bindings/sql/cipherstash-encrypt.sql  | 38 +++++++++++++++++--
 crates/eql-bindings/sql/release-manifest.json |  4 +-
 packages/eql/CHANGELOG.md                     | 13 +++++++
 packages/eql/package.json                     |  2 +-
 packages/eql/sql/cipherstash-encrypt.sql      | 38 +++++++++++++++++--
 packages/eql/sql/release-manifest.json        |  4 +-
 .../eql/src/generated/release-manifest.ts     |  4 +-
 10 files changed, 92 insertions(+), 27 deletions(-)
 delete mode 100644 .changeset/rename-ste-vec-contains.md

diff --git a/.changeset/rename-ste-vec-contains.md b/.changeset/rename-ste-vec-contains.md
deleted file mode 100644
index 1b1b25c53..000000000
--- a/.changeset/rename-ste-vec-contains.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-'@cipherstash/eql': patch
----
-
-**`eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`.** This
-consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family,
-matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`,
-`jsonb_query`). The old name remains available as a deprecated compatibility
-alias, so existing direct callers continue to work; new code should use
-`jsonb_document_contains`. The `json` `@>` / `<@` containment operators and the
-raw-jsonb function-form entry points, `eql_v3.jsonb_contains(jsonb, jsonb)` and
-`eql_v3.jsonb_contained_by(jsonb, jsonb)`, are unchanged.
diff --git a/Cargo.lock b/Cargo.lock
index a7619f5f8..e76325bbd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1131,7 +1131,7 @@ dependencies = [
 
 [[package]]
 name = "eql-bindings"
-version = "3.0.4"
+version = "3.0.5"
 dependencies = [
  "eql-domains",
  "schemars",
diff --git a/crates/eql-bindings/Cargo.toml b/crates/eql-bindings/Cargo.toml
index 83cf589fd..962a1f37c 100644
--- a/crates/eql-bindings/Cargo.toml
+++ b/crates/eql-bindings/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "eql-bindings"
-version = "3.0.4"
+version = "3.0.5"
 edition = "2021"
 description = "Canonical wire types for EQL payloads — single source of truth for Rust, TypeScript (ts-rs), and JSON Schema (schemars)."
 # crates.io metadata. `license` is REQUIRED by crates.io — publish fails without
diff --git a/crates/eql-bindings/sql/cipherstash-encrypt.sql b/crates/eql-bindings/sql/cipherstash-encrypt.sql
index dcd10521f..88c460300 100644
--- a/crates/eql-bindings/sql/cipherstash-encrypt.sql
+++ b/crates/eql-bindings/sql/cipherstash-encrypt.sql
@@ -23444,6 +23444,38 @@ AS $$
        @> eql_v3.to_ste_vec_query(b)::jsonb
 $$;
 
+--! @cond deprecated_compatibility
+--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).
+--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).
+--! @param a jsonb[] sv array to search within.
+--! @param b jsonb sv element to search for.
+--! @return boolean True if b's selector is present in any element of a.
+CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)
+  RETURNS boolean
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$
+  SELECT eql_v3.jsonb_document_contains(a, b)
+$$;
+
+COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS
+  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';
+
+--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).
+--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).
+--! @param a public.eql_v3_json_search Container.
+--! @param b public.eql_v3_json_search Elements to find.
+--! @return boolean True if all elements of b are contained in a.
+CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)
+  RETURNS boolean
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$
+  SELECT eql_v3.jsonb_document_contains(a, b)
+$$;
+
+COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS
+  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';
+--! @endcond
+
 ------------------------------------------------------------------------------
 -- Path queries (text selector only)
 ------------------------------------------------------------------------------
@@ -59437,7 +59469,7 @@ DROP FUNCTION IF EXISTS eql_v3.version();
 --! @brief EQL version reporting (self-contained eql_v3 surface)
 --!
 --! This file is auto-generated from src/v3/version.template during build.
---! The 3.0.4 placeholder is replaced with the actual release
+--! The 3.0.5 placeholder is replaced with the actual release
 --! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`,
 --! or "DEV" for development builds.
 
@@ -59456,14 +59488,14 @@ CREATE FUNCTION eql_v3.version()
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT '3.0.4';
+  SELECT '3.0.5';
 $$ LANGUAGE SQL;
 
 --! @brief Schema-level version marker for obj_description() discoverability
 --!
 --! Mirrors eql_v3.version() as a comment on the schema so the installed
 --! version can also be read via obj_description('eql_v3'::regnamespace).
-COMMENT ON SCHEMA eql_v3 IS '3.0.4';
+COMMENT ON SCHEMA eql_v3 IS '3.0.5';
 --! @file pin_search_path_v3.sql
 --! @brief Post-install: pin search_path on every eql_v3.* function.
 --!
diff --git a/crates/eql-bindings/sql/release-manifest.json b/crates/eql-bindings/sql/release-manifest.json
index 4cd5728ed..f0203fcc7 100644
--- a/crates/eql-bindings/sql/release-manifest.json
+++ b/crates/eql-bindings/sql/release-manifest.json
@@ -1,6 +1,6 @@
 {
-  "eqlVersion": "3.0.4",
+  "eqlVersion": "3.0.5",
   "schemaVersion": 3,
-  "installSqlSha256": "a92cc04132512a43bf18b148c61fc0c205c42627709f1f641292519dc410873c",
+  "installSqlSha256": "accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048",
   "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9"
 }
diff --git a/packages/eql/CHANGELOG.md b/packages/eql/CHANGELOG.md
index d78abe309..10e5a4c61 100644
--- a/packages/eql/CHANGELOG.md
+++ b/packages/eql/CHANGELOG.md
@@ -1,5 +1,18 @@
 # @cipherstash/eql
 
+## 3.0.5
+
+### Patch Changes
+
+- 4c2bb92: **`eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`.** This
+  consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family,
+  matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`,
+  `jsonb_query`). The old name remains available as a deprecated compatibility
+  alias, so existing direct callers continue to work; new code should use
+  `jsonb_document_contains`. The `json` `@>` / `<@` containment operators and the
+  raw-jsonb function-form entry points, `eql_v3.jsonb_contains(jsonb, jsonb)` and
+  `eql_v3.jsonb_contained_by(jsonb, jsonb)`, are unchanged.
+
 ## 3.0.4
 
 ### Patch Changes
diff --git a/packages/eql/package.json b/packages/eql/package.json
index 07eed4762..125e5efc7 100644
--- a/packages/eql/package.json
+++ b/packages/eql/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@cipherstash/eql",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "description": "Canonical EQL v3 wire types, JSON schemas, and SQL bundle.",
   "keywords": [
     "eql",
diff --git a/packages/eql/sql/cipherstash-encrypt.sql b/packages/eql/sql/cipherstash-encrypt.sql
index dcd10521f..88c460300 100644
--- a/packages/eql/sql/cipherstash-encrypt.sql
+++ b/packages/eql/sql/cipherstash-encrypt.sql
@@ -23444,6 +23444,38 @@ AS $$
        @> eql_v3.to_ste_vec_query(b)::jsonb
 $$;
 
+--! @cond deprecated_compatibility
+--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).
+--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).
+--! @param a jsonb[] sv array to search within.
+--! @param b jsonb sv element to search for.
+--! @return boolean True if b's selector is present in any element of a.
+CREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)
+  RETURNS boolean
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$
+  SELECT eql_v3.jsonb_document_contains(a, b)
+$$;
+
+COMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS
+  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';
+
+--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).
+--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).
+--! @param a public.eql_v3_json_search Container.
+--! @param b public.eql_v3_json_search Elements to find.
+--! @return boolean True if all elements of b are contained in a.
+CREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)
+  RETURNS boolean
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$
+  SELECT eql_v3.jsonb_document_contains(a, b)
+$$;
+
+COMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS
+  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';
+--! @endcond
+
 ------------------------------------------------------------------------------
 -- Path queries (text selector only)
 ------------------------------------------------------------------------------
@@ -59437,7 +59469,7 @@ DROP FUNCTION IF EXISTS eql_v3.version();
 --! @brief EQL version reporting (self-contained eql_v3 surface)
 --!
 --! This file is auto-generated from src/v3/version.template during build.
---! The 3.0.4 placeholder is replaced with the actual release
+--! The 3.0.5 placeholder is replaced with the actual release
 --! version (bare semver, e.g. "3.0.0") supplied via `mise run build --version`,
 --! or "DEV" for development builds.
 
@@ -59456,14 +59488,14 @@ CREATE FUNCTION eql_v3.version()
   RETURNS text
   IMMUTABLE STRICT PARALLEL SAFE
 AS $$
-  SELECT '3.0.4';
+  SELECT '3.0.5';
 $$ LANGUAGE SQL;
 
 --! @brief Schema-level version marker for obj_description() discoverability
 --!
 --! Mirrors eql_v3.version() as a comment on the schema so the installed
 --! version can also be read via obj_description('eql_v3'::regnamespace).
-COMMENT ON SCHEMA eql_v3 IS '3.0.4';
+COMMENT ON SCHEMA eql_v3 IS '3.0.5';
 --! @file pin_search_path_v3.sql
 --! @brief Post-install: pin search_path on every eql_v3.* function.
 --!
diff --git a/packages/eql/sql/release-manifest.json b/packages/eql/sql/release-manifest.json
index 4cd5728ed..f0203fcc7 100644
--- a/packages/eql/sql/release-manifest.json
+++ b/packages/eql/sql/release-manifest.json
@@ -1,6 +1,6 @@
 {
-  "eqlVersion": "3.0.4",
+  "eqlVersion": "3.0.5",
   "schemaVersion": 3,
-  "installSqlSha256": "a92cc04132512a43bf18b148c61fc0c205c42627709f1f641292519dc410873c",
+  "installSqlSha256": "accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048",
   "uninstallSqlSha256": "b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9"
 }
diff --git a/packages/eql/src/generated/release-manifest.ts b/packages/eql/src/generated/release-manifest.ts
index b0f19bf12..21c403c1c 100644
--- a/packages/eql/src/generated/release-manifest.ts
+++ b/packages/eql/src/generated/release-manifest.ts
@@ -1,6 +1,6 @@
 export const releaseManifest = {
-  eqlVersion: '3.0.4',
+  eqlVersion: '3.0.5',
   schemaVersion: 3,
-  installSqlSha256: 'a92cc04132512a43bf18b148c61fc0c205c42627709f1f641292519dc410873c',
+  installSqlSha256: 'accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048',
   uninstallSqlSha256: 'b1b5131b8175c5d04da9ada108d25c81c5772b15fad79a6c419ebb32d18c60a9',
 } as const

From 4098a1f244f69b4608e8e74af519958873a9d897 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:25:48 +1000
Subject: [PATCH 09/20] fix(release): make the version hook runnable, and
 refuse to half-publish
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two defects that only fire after a merge, found in PR review.

THE VERSION HOOK COULD NOT RUN. `release.yml` passes `version: pnpm run
version`, which chains `scripts/sync-lockstep-versions.mjs` ->
`mise run release:prepare_bindings_assets` -> `cargo run -p eql-codegen`.
The `release` job installed pnpm, Node and node-gyp and nothing else; mise
is not on GitHub's ubuntu images. `.changeset/` already holds live
changesets, so changesets/action takes its version branch on the next push
to main regardless of this PR — `pnpm run version` would have died with
ENOENT and no Version Packages PR would have been opened at all.
`release-version-hook.test.mjs` asserted the wiring existed; nothing
asserted the job could execute it. `workflow-mise-setup.test.mjs` now
resolves command chains — action input -> npm script -> spawned binary —
and requires a mise setup step at a lower index in any job that reaches
one. `add_shims_to_path: false` is load-bearing and would not survive a
copy-paste from test-eql.yml: mise's shim dir is prepended to PATH for
every later step, so mise's pinned Node 22 would shadow setup-node's and
`changeset publish` would shell out to its bundled npm 10.x, below the
11.5.1 that OIDC trusted publishing requires.

`changeset publish` HAS NO IDEA WHAT IT IS DOING. It publishes every public
workspace package whose version is absent from npm — changeset or no
changeset — with `Promise.all` and no dependency ordering, and
`publishAPackage` returns a failure rather than throwing it. So a package
that cannot publish does not stop the siblings that depend on it: they ship
pointing at a version nobody can install. `publishBlockers` in
release-gate.mjs answers that question before anything publishes and exits
non-zero, which fails `gate` and skips `release` entirely.

`FROZEN_PUBLISHERS` has to be written down rather than derived: npm exposes
no way to ask "would a publish from here be accepted?", and provenance on
the last release is evidence about the past, not permission for the next.
Its FFI half turns lint-no-ffi-changeset.mjs's unstated assumption — that
all seven are already on npm at the workspace version — into a checked one,
which is precisely what the hand-applied EQL 3.0.5 bump showed it needed.

The third verdict in the range check is NOT SAFE, MERELY NOT WORSE: a
dependency being published in the same release is allowed, because that is
every ordinary release here, and changesets' lack of ordering leaves a
window nothing at this layer can close. What it can do is separate that
transient window from a permanent hole.

Also: `changeset:version` was a bare `changeset version` that skipped the
lockstep sync while AGENTS.md documented it as the release flow, and
`changeset:publish` skipped the build the same way. Both now route through
the wrappers, and the test states the rule over the scripts rather than
over the two names.

packages/protect-ffi/Cargo.lock was stale (`cargo metadata --locked` exit
101): it records eql-bindings, whose version sync-lockstep-versions.mjs
moves, and nothing refreshed it — `packages/eql`'s lock is refreshed as a
side effect of the SQL build, that one by nothing at all. The script now
discovers every lock recording the crate from a path and refreshes each.
---
 .github/workflows/release.yml                 |  61 +++
 .github/workflows/tests.yml                   |  24 +
 package.json                                  |   4 +-
 packages/protect-ffi/Cargo.lock               |  10 +-
 .../__tests__/cargo-lock-freshness.test.mjs   | 192 +++++++
 scripts/__tests__/release-gate.test.mjs       | 473 +++++++++++++++++-
 .../__tests__/release-version-hook.test.mjs   |  66 +++
 .../__tests__/sync-lockstep-versions.test.mjs |  85 +++-
 .../__tests__/workflow-mise-setup.test.mjs    | 235 +++++++++
 scripts/release-gate.mjs                      | 446 ++++++++++++++++-
 scripts/sync-lockstep-versions.mjs            | 135 ++++-
 11 files changed, 1713 insertions(+), 18 deletions(-)
 create mode 100644 scripts/__tests__/cargo-lock-freshness.test.mjs
 create mode 100644 scripts/__tests__/workflow-mise-setup.test.mjs

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3c4245dcc..6c58a4491 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -273,6 +273,67 @@ jobs:
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
+      # REQUIRED BY `version:` BELOW, and nothing in this file says so without
+      # this comment — which is why there is also a test. `pnpm run version` is
+      # `changeset version && node scripts/sync-lockstep-versions.mjs`, and that
+      # script ends in `execFileSync('mise', ['run',
+      # 'release:prepare_bindings_assets', …])`, which reaches
+      # `packages/eql/tasks/build.sh` and two `cargo run -p eql-codegen` calls.
+      # mise is NOT preinstalled on GitHub's ubuntu images, so without this step
+      # the hook dies with ENOENT — AFTER `changeset version` has already
+      # rewritten every manifest and changelog, in a job holding
+      # `contents: write`. Asserted by
+      # scripts/__tests__/workflow-mise-setup.test.mjs.
+      #
+      # It only fires on the branch where `.changeset/` is non-empty (the
+      # Version Packages branch), which is why a publish rehearsal never
+      # exercised it.
+      #
+      # `working_directory: packages/eql` for the reason test-eql.yml records at
+      # length: mise reads config from the current directory and its PARENTS, so
+      # an action running at the repo root never sees `packages/eql/mise.toml`.
+      # It would install nothing and leave the config untrusted, and the first
+      # `mise run` fails with "Config files … are not trusted" — which reads as
+      # a toolchain problem rather than a path one. That file is also where the
+      # Rust toolchain comes from (`[tools] rust`), so this step is the cargo
+      # setup as well; there is deliberately no second one.
+      #
+      # `cache: false` IS NOT THE DEFAULT — jdx/mise-action caches by default,
+      # and scripts/lint-no-workflow-caching.mjs forbids a GitHub Actions cache
+      # restore anywhere an artifact gets published. A poisoned entry here would
+      # execute in the job that holds the npm publishing credential.
+      #
+      # `add_shims_to_path: false` IS LOAD-BEARING, and it is the input a
+      # copy-paste from test-eql.yml would not carry. `packages/eql/mise.toml`
+      # pins `node = "22"` under `[tools]`, and mise's shim directory is
+      # PREPENDED to PATH for every later step — so with the default `true`,
+      # mise's own Node would shadow the one `actions/setup-node` installed, and
+      # `changeset publish` would shell out to that Node's bundled npm 10.x
+      # instead of the `npm@^11.5.1` installed above. OIDC trusted publishing
+      # requires >= 11.5.1 and fails with E404 below it, which is the exact
+      # failure the two comments above this step exist to prevent. `mise run`
+      # resolves its own toolchain internally, so nothing here needs the shims.
+      #
+      # `env: false` for a smaller version of the same argument: the default
+      # exports that file's `[env]` block — `DATABASE_URL`, `POSTGRES_PASSWORD`
+      # and friends, all pointed at a Postgres this job does not have — into
+      # GITHUB_ENV for every subsequent step.
+      #
+      # SHA-pinned, matching .github/actions/build-ffi-binding/action.yml:
+      # mise-action executes third-party code in the job that publishes, so a
+      # mutable `@v4` would let that code change with no commit here. The pin is
+      # the same v4 commit test-eql.yml uses. Dependabot moves the pin and the
+      # trailing comment together (.github/dependabot.yml covers github-actions).
+      - name: Install mise (the lockstep version hook shells out to it)
+        uses: jdx/mise-action@1648a7812b9aeae629881980618f079932869151 # v4
+        with:
+          version: 2026.4.0
+          install: true
+          cache: false
+          working_directory: packages/eql
+          add_shims_to_path: false
+          env: false
+
       - name: Publish to npm
         id: changesets
         uses: changesets/action@v1.9.0
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index fcc766b6b..8db055cc7 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -271,6 +271,30 @@ jobs:
       - name: Lint — no protect-ffi changeset before the publishing cutover
         run: pnpm run lint:ffi-changeset
 
+      # THE SAME GATE release.yml RUNS, one merge earlier.
+      #
+      # `changeset publish` publishes every public workspace package whose
+      # version is absent from npm — with no dependency ordering, and a failed
+      # publish returns a result rather than throwing, so it does not stop the
+      # siblings that depend on it. A merge can therefore ARM a release that
+      # cannot succeed: `@cipherstash/eql` was hand-bumped to 3.0.5 while npm's
+      # newest is 3.0.4 and its trusted publisher still names
+      # cipherstash/encrypt-query-language, and `packages/cli` and
+      # `packages/stack-prisma` carry it in RUNTIME dependencies, so both would
+      # pack `^3.0.5` — a range no published version satisfies.
+      #
+      # The gate in release.yml blocks the publish, which is the load-bearing
+      # half. This step is the half that says so BEFORE the merge rather than
+      # after it, which is the difference between a red pull request and a red
+      # main. Same script, same verdict, no second copy to drift.
+      #
+      # It talks to the registry, in a job that already installs the whole
+      # workspace from it — so this adds a class of dependency the job does not
+      # already have, only a few more requests. A lookup that fails for any
+      # reason other than a 404 throws rather than being read as "published".
+      - name: Lint — this tree can be published, and installed
+        run: pnpm run release:gate
+
       - name: Test — lint script self-tests
         run: pnpm run test:scripts
 
diff --git a/package.json b/package.json
index c9035a76f..a279d3109 100644
--- a/package.json
+++ b/package.json
@@ -23,8 +23,8 @@
     "build": "turbo build --filter './packages/*'",
     "build:js": "turbo build --filter './packages/nextjs'",
     "changeset": "changeset",
-    "changeset:version": "changeset version",
-    "changeset:publish": "changeset publish",
+    "changeset:version": "pnpm run version",
+    "changeset:publish": "pnpm run release",
     "dev": "turbo dev --filter './packages/*'",
     "clean": "rimraf --glob **/.next **/.turbo **/dist **/node_modules",
     "code:fix": "biome check --write",
diff --git a/packages/protect-ffi/Cargo.lock b/packages/protect-ffi/Cargo.lock
index 845d99445..c9f921fa0 100644
--- a/packages/protect-ffi/Cargo.lock
+++ b/packages/protect-ffi/Cargo.lock
@@ -1058,7 +1058,7 @@ dependencies = [
 
 [[package]]
 name = "eql-bindings"
-version = "3.0.4"
+version = "3.0.5"
 dependencies = [
  "schemars",
  "serde",
@@ -1079,7 +1079,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3021,7 +3021,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3357,7 +3357,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -4388,7 +4388,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
diff --git a/scripts/__tests__/cargo-lock-freshness.test.mjs b/scripts/__tests__/cargo-lock-freshness.test.mjs
new file mode 100644
index 000000000..9106cf5e0
--- /dev/null
+++ b/scripts/__tests__/cargo-lock-freshness.test.mjs
@@ -0,0 +1,192 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { REPO_ROOT } from './lib/repo-root.mjs'
+
+/**
+ * Every crate this repo owns must be recorded in every `Cargo.lock` at the
+ * version its own `Cargo.toml` declares.
+ *
+ * ## The drift this catches, and why nothing else does
+ *
+ * `scripts/sync-lockstep-versions.mjs` rewrites
+ * `packages/eql/crates/eql-bindings/Cargo.toml` on every lockstep bump — that
+ * is its job. `packages/protect-ffi` depends on that crate BY PATH
+ * (`crates/protect-ffi/Cargo.toml`), so its `Cargo.lock` records the version
+ * too, and nothing was updating it. After the 3.0.5 bump the lock still said
+ * `eql-bindings 3.0.4` and `cargo metadata --locked` exited 101.
+ *
+ * Nothing failed. Not one command in this repo passes `--locked`:
+ * `build:native` is a plain `cargo build --release`, so every CI job that
+ * touches Rust silently regenerated the lock, used the regenerated one, and
+ * threw it away with the runner. The committed file drifted further from the
+ * tree on each lockstep bump while every job stayed green.
+ *
+ * ## Why a version comparison rather than `cargo metadata --locked`
+ *
+ * `--locked` is the exact check and it needs a Rust toolchain. `AGENTS.md` is
+ * explicit that the default `test` and `build` scripts must never invoke cargo
+ * — root `pnpm test` reaches `packages/protect-ffi`, so a cargo call on that
+ * path is a Rust toolchain on every contributor's machine — and `pnpm run
+ * test:scripts` has the same reach, since everyone runs it.
+ *
+ * So this asserts the property that actually broke, with node builtins: a
+ * source-less `[[package]]` entry in a lock is a crate resolved from this
+ * tree, and its version is knowable by reading the crate's manifest. That is
+ * narrower than `--locked` — a lock stale because a crate gained a NEW
+ * dependency still passes here — but it is the whole of the lockstep failure
+ * mode, it runs everywhere, and it costs nothing. Pairing it with a `--locked`
+ * invocation on `packages/protect-ffi`'s `test:cargo` path would close the
+ * remainder; that script is owned elsewhere.
+ */
+
+/** Same skip set, and the same reasons, as `lint-no-eql-registry-pins.mjs`. */
+const SKIP_DIRS = new Set([
+  '.git',
+  'node_modules',
+  'target',
+  'dist',
+  '.turbo',
+  '.next',
+])
+
+/** Every file named `name` under the repo, repo-relative and POSIX-spelled. */
+function findFiles(name) {
+  const found = []
+  const walk = (abs) => {
+    for (const entry of readdirSync(abs, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(join(abs, entry.name))
+      } else if (entry.name === name) {
+        found.push(join(abs, entry.name))
+      }
+    }
+  }
+  walk(REPO_ROOT)
+  return found
+    .map((abs) => relative(REPO_ROOT, abs).split(sep).join('/'))
+    .sort()
+}
+
+/**
+ * `[package] name` and `version` from one `Cargo.toml`.
+ *
+ * Anchored to the `[package]` table for the reason `bumpCargoPackageVersion`
+ * is: a `[dependencies.foo]` long-form table also carries a column-0
+ * `version = "…"` line, and reading "the first version in the file" would pick
+ * up whichever came first.
+ */
+function crateManifest(source) {
+  const section = source.match(/^\[package\]\n(?:(?!^\[).*\n)*/m)
+  if (!section) return null
+  const name = /^name = "([^"]*)"$/m.exec(section[0])
+  const version = /^version = "([^"]*)"$/m.exec(section[0])
+  return name && version ? { name: name[1], version: version[1] } : null
+}
+
+/**
+ * The `[[package]]` entries of a `Cargo.lock` that resolve from THIS tree.
+ *
+ * A registry or git dependency carries a `source = "…"` key; a path dependency
+ * and a workspace member carry none. That absence is the whole test for
+ * "cargo resolved this from a directory", and it is how cargo itself
+ * distinguishes them.
+ */
+export function localLockEntries(source) {
+  return source
+    .split(/^\[\[package\]\]$/m)
+    .slice(1)
+    .map((block) => {
+      const name = /^name = "([^"]*)"$/m.exec(block)
+      const version = /^version = "([^"]*)"$/m.exec(block)
+      const source_ = /^source = "/m.test(block)
+      return name && version && !source_
+        ? { name: name[1], version: version[1] }
+        : null
+    })
+    .filter(Boolean)
+}
+
+/** name -> { version, file } for every crate manifest in the tree. */
+const CRATES = new Map()
+const AMBIGUOUS = []
+for (const file of findFiles('Cargo.toml')) {
+  const crate = crateManifest(readFileSync(join(REPO_ROOT, file), 'utf8'))
+  if (!crate) continue // a virtual manifest: `[workspace]` with no `[package]`
+  const existing = CRATES.get(crate.name)
+  if (existing && existing.version !== crate.version) {
+    AMBIGUOUS.push(`${crate.name}: ${existing.file} vs ${file}`)
+  }
+  CRATES.set(crate.name, { ...crate, file })
+}
+
+const LOCKS = findFiles('Cargo.lock')
+
+/** Every (lock, local crate) pair, with the version each side records. */
+const PAIRS = LOCKS.flatMap((lock) =>
+  localLockEntries(readFileSync(join(REPO_ROOT, lock), 'utf8')).map(
+    (entry) => ({
+      lock,
+      name: entry.name,
+      locked: entry.version,
+      onDisk: CRATES.get(entry.name)?.version ?? null,
+    }),
+  ),
+)
+
+describe('Cargo.lock records this tree’s crates at their real versions', () => {
+  it('finds locks and crates to compare', () => {
+    // The floor. Discovery over the tree means a walk that stops matching —
+    // a new SKIP_DIRS entry, a rename — turns this whole file green while
+    // checking nothing.
+    expect(LOCKS.length).toBeGreaterThan(0)
+    expect(PAIRS.length).toBeGreaterThan(0)
+  })
+
+  it('covers eql-bindings, the crate the lockstep bump rewrites', () => {
+    // Named specifically because it is the one with a mechanism actively
+    // pushing it out of sync: `scripts/sync-lockstep-versions.mjs` writes its
+    // `Cargo.toml` on every release. If this crate ever drops out of the pair
+    // set, the check that matters most has silently stopped running.
+    expect(PAIRS.filter(({ name }) => name === 'eql-bindings').length).toBe(
+      LOCKS.length,
+    )
+  })
+
+  it('resolves every locked local crate to a manifest on disk', () => {
+    // A source-less entry naming a crate this tree does not contain means the
+    // scan lost its subject — a path dependency pointing outside the repo, or
+    // a walk that no longer reaches the crate. Either way the comparison below
+    // is not being made, which must not read as a pass.
+    expect(
+      PAIRS.filter(({ onDisk }) => onDisk === null).map(
+        ({ lock, name }) => `${lock} :: ${name}`,
+      ),
+    ).toEqual([])
+  })
+
+  it('has one version per crate name across the tree', () => {
+    // The name -> version map is keyed on the crate name alone, so two crates
+    // sharing a name at different versions would make the comparison depend on
+    // walk order. Fail rather than pick.
+    expect(AMBIGUOUS).toEqual([])
+  })
+
+  it('locks each crate at the version its Cargo.toml declares', () => {
+    // THE DEFECT. `packages/protect-ffi/Cargo.lock` said `eql-bindings 3.0.4`
+    // while the crate said 3.0.5, because the lockstep sync rewrote the
+    // manifest and no command in this repo passes `--locked`.
+    const offenders = PAIRS.filter(
+      ({ locked, onDisk }) => locked !== onDisk,
+    ).map(
+      ({ lock, name, locked, onDisk }) =>
+        `${lock}: ${name} locked at ${locked}, ${CRATES.get(name).file} declares ${onDisk}`,
+    )
+    expect(
+      offenders,
+      'A committed Cargo.lock disagrees with a crate manifest in this tree. Refresh it with ' +
+        '`cargo update --offline --package <crate>` in the workspace holding the lock — no network ' +
+        'needed, because the crate resolves from a path.',
+    ).toEqual([])
+  })
+})
diff --git a/scripts/__tests__/release-gate.test.mjs b/scripts/__tests__/release-gate.test.mjs
index 992ea11cc..a2ae18255 100644
--- a/scripts/__tests__/release-gate.test.mjs
+++ b/scripts/__tests__/release-gate.test.mjs
@@ -1,13 +1,26 @@
-import { readFileSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import {
+  chmodSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import yaml from 'js-yaml'
 import { describe, expect, it } from 'vitest'
 import {
   classify,
+  packedRange,
+  publishBlockers,
+  satisfies,
   unpublished,
+  workspaceManifests,
   workspacePackagePatterns,
 } from '../release-gate.mjs'
 import { REPO_ROOT } from './lib/repo-root.mjs'
+import { readWorkflow } from './lib/workflows.mjs'
 
 /**
  * The gate decides what a push to `main` still has to publish, and it is
@@ -174,3 +187,461 @@ describe('classify', () => {
     expect(classify([])).toEqual({ ffi: false, js: false })
   })
 })
+
+/**
+ * WHAT ARMS A RELEASE THAT CANNOT SUCCEED.
+ *
+ * `changeset publish` publishes every public workspace package whose committed
+ * version is absent from npm — changeset or no changeset. In the installed
+ * 2.31.0 it does that with no dependency ordering (`Promise.all`) and
+ * `publishAPackage` RETURNS a result rather than throwing, so one package's
+ * failed publish does not stop its siblings. A package that cannot publish
+ * therefore does not abort the release; it just does not arrive, and everything
+ * that depends on it ships pointing at a version nobody can install.
+ *
+ * That is not hypothetical here. `@cipherstash/eql` was hand-bumped to 3.0.5 in
+ * the workspace while npm's newest is 3.0.4 and its trusted publisher still
+ * names `cipherstash/encrypt-query-language` — so its publish from this
+ * repository is rejected, while `packages/cli` and `packages/stack-prisma`
+ * carry `"@cipherstash/eql": "workspace:^"` in their RUNTIME dependencies,
+ * which pnpm rewrites to `^3.0.5` at pack time. A range no published version
+ * satisfies, in a tarball that publishes fine.
+ */
+
+const EQL = '@cipherstash/eql'
+
+describe('packedRange', () => {
+  it('resolves the three bare protocol forms the way pnpm does', () => {
+    // `workspace:*` is an EXACT pin, not a wildcard — the distinction the whole
+    // check turns on, since it makes the range unsatisfiable by anything but
+    // the one version.
+    expect(packedRange('workspace:*', '1.5.0')).toBe('1.5.0')
+    expect(packedRange('workspace:^', '1.5.0')).toBe('^1.5.0')
+    expect(packedRange('workspace:~', '1.5.0')).toBe('~1.5.0')
+  })
+
+  it('passes an explicit range through verbatim', () => {
+    expect(packedRange('workspace:^1.0.0', '1.5.0')).toBe('^1.0.0')
+    expect(packedRange('workspace:1.2.3', '1.5.0')).toBe('1.2.3')
+  })
+
+  it('ignores a specifier that is not the workspace protocol', () => {
+    // Registry ranges are somebody else's problem: npm resolves them itself.
+    expect(packedRange('^1.0.0', '1.5.0')).toBeNull()
+    expect(packedRange('catalog:repo', '1.5.0')).toBeNull()
+  })
+})
+
+describe('satisfies', () => {
+  it('reads an exact pin', () => {
+    expect(satisfies('1.5.0', '1.5.0')).toBe(true)
+    expect(satisfies('1.5.1', '1.5.0')).toBe(false)
+  })
+
+  it('reads caret, including the 0.x and 0.0.x narrowings', () => {
+    expect(satisfies('1.9.9', '^1.5.0')).toBe(true)
+    expect(satisfies('2.0.0', '^1.5.0')).toBe(false)
+    expect(satisfies('1.4.9', '^1.5.0')).toBe(false)
+    // ^0.5.0 does NOT admit 0.6.0 — the case that decides whether
+    // `@cipherstash/protect-ffi@0.31.0`'s siblings are read correctly.
+    expect(satisfies('0.5.9', '^0.5.0')).toBe(true)
+    expect(satisfies('0.6.0', '^0.5.0')).toBe(false)
+    expect(satisfies('0.0.4', '^0.0.3')).toBe(false)
+  })
+
+  it('reads tilde', () => {
+    expect(satisfies('1.5.9', '~1.5.0')).toBe(true)
+    expect(satisfies('1.6.0', '~1.5.0')).toBe(false)
+  })
+
+  it('does not let a prerelease satisfy a stable range', () => {
+    // THE ONE THAT DECIDES THIS REPO'S ANSWER. npm carries
+    // `@cipherstash/eql@3.0.0-alpha.2` and friends, and a naive comparison puts
+    // some of them inside `^3.0.5`'s window — which would report the range as
+    // satisfiable and wave the whole defect through.
+    expect(satisfies('3.1.0-alpha.1', '^3.0.5')).toBe(false)
+    expect(satisfies('3.0.0-alpha.2', '^3.0.0')).toBe(false)
+    // …while a prerelease of the range's OWN tuple still counts, per semver.
+    expect(satisfies('3.0.5-rc.2', '^3.0.5-rc.1')).toBe(true)
+  })
+
+  it('throws on a range it cannot read, rather than guessing', () => {
+    // Every failure mode in this file fails loudly — see the script header. A
+    // range read as "unsatisfiable" would freeze a release that is fine; one
+    // read as "satisfiable" would publish the broken tarball.
+    expect(() => satisfies('1.0.0', '>=1.0.0 <2.0.0')).toThrow(/range/i)
+    expect(() => satisfies('1.0.0', '1.x')).toThrow(/range/i)
+  })
+})
+
+describe('publishBlockers', () => {
+  /** A registry where nothing has ever been published. */
+  const empty = () => null
+
+  it('blocks a frozen package whose committed version is not on npm', () => {
+    // CHECK A. `changeset publish` will attempt this package because its
+    // version is absent, and the attempt is rejected — npm trusted publishing
+    // is bound to a repository, and this one is not it.
+    const blockers = publishBlockers({
+      manifests: [
+        { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] },
+      ],
+      lookup: () => ['3.0.4'],
+      frozen: new Map([[EQL, 'publisher not repointed yet']]),
+    })
+    expect(blockers.map((b) => b.kind)).toEqual(['frozen-publisher'])
+    expect(blockers[0].package).toBe(EQL)
+  })
+
+  it('lets a frozen package through once its committed version IS on npm', () => {
+    // The state the seven protect-ffi packages are in, and the unstated
+    // assumption `scripts/lint-no-ffi-changeset.mjs` rests on: at the published
+    // version, `changeset publish` skips them and the frozen publisher never
+    // matters. This is that assumption, checked.
+    expect(
+      publishBlockers({
+        manifests: [
+          { name: EQL, version: '3.0.4', private: false, workspaceDeps: [] },
+        ],
+        lookup: () => ['3.0.4'],
+        frozen: new Map([[EQL, 'publisher not repointed yet']]),
+      }),
+    ).toEqual([])
+  })
+
+  it('blocks a runtime range that only a frozen package could satisfy', () => {
+    // CHECK B, and the blast radius. `stash` publishes fine; it just ships a
+    // dependency on a version that will never exist.
+    const blockers = publishBlockers({
+      manifests: [
+        { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] },
+        {
+          name: 'stash',
+          version: '1.0.1',
+          private: false,
+          workspaceDeps: [
+            { table: 'dependencies', name: EQL, spec: 'workspace:^' },
+          ],
+        },
+      ],
+      lookup: (name) => (name === EQL ? ['3.0.4'] : ['1.0.0']),
+      frozen: new Map([[EQL, 'publisher not repointed yet']]),
+    })
+    const range = blockers.find((b) => b.kind === 'frozen-dependency')
+    expect(range).toBeDefined()
+    expect(range.package).toBe('stash')
+    expect(range.dependency).toBe(EQL)
+    expect(range.range).toBe('^3.0.5')
+  })
+
+  it('allows a range only this same release will satisfy, when the dep can publish', () => {
+    // THE FALSE POSITIVE THAT WOULD MAKE THIS GATE UNUSABLE. Every ordinary
+    // release of this repo moves the six-package fixed group together, so at
+    // gate time `@cipherstash/stack-drizzle@1.0.1` depends on
+    // `@cipherstash/stack@1.0.1` and NEITHER is on npm yet. Failing that would
+    // freeze the repo permanently rather than catch anything.
+    expect(
+      publishBlockers({
+        manifests: [
+          {
+            name: 'stack',
+            version: '1.0.1',
+            private: false,
+            workspaceDeps: [],
+          },
+          {
+            name: 'drizzle',
+            version: '1.0.1',
+            private: false,
+            workspaceDeps: [
+              { table: 'dependencies', name: 'stack', spec: 'workspace:*' },
+            ],
+          },
+        ],
+        lookup: () => ['1.0.0'],
+        frozen: new Map(),
+      }),
+    ).toEqual([])
+  })
+
+  it('blocks a runtime dependency on a package that is never published', () => {
+    // `@cipherstash/test-kit` is `private: true`. A runtime `workspace:*` on it
+    // packs a range for a package with no registry entry at all — the same
+    // broken install, arrived at a different way.
+    const blockers = publishBlockers({
+      manifests: [
+        {
+          name: 'test-kit',
+          version: '0.0.1',
+          private: true,
+          workspaceDeps: [],
+        },
+        {
+          name: 'stack',
+          version: '1.0.0',
+          private: false,
+          workspaceDeps: [
+            { table: 'dependencies', name: 'test-kit', spec: 'workspace:*' },
+          ],
+        },
+      ],
+      lookup: empty,
+      frozen: new Map(),
+    })
+    expect(blockers.map((b) => b.kind)).toEqual(['private-dependency'])
+  })
+
+  it('blocks a hand-written range the workspace version cannot satisfy', () => {
+    // `workspace:^2.0.0` against a 1.x member. pnpm writes it out verbatim, so
+    // nothing downstream notices; it is simply a manifest that cannot resolve.
+    const blockers = publishBlockers({
+      manifests: [
+        { name: 'stack', version: '1.0.0', private: false, workspaceDeps: [] },
+        {
+          name: 'drizzle',
+          version: '1.0.0',
+          private: false,
+          workspaceDeps: [
+            { table: 'dependencies', name: 'stack', spec: 'workspace:^2.0.0' },
+          ],
+        },
+      ],
+      lookup: () => ['1.0.0'],
+      frozen: new Map(),
+    })
+    expect(blockers.map((b) => b.kind)).toEqual(['unsatisfiable-range'])
+  })
+
+  it('ignores devDependencies', () => {
+    // A published tarball keeps its devDependencies in the manifest, but no
+    // consumer installs them, so an unsatisfiable one breaks nothing. This is
+    // why `packages/stack`'s `@cipherstash/eql: workspace:^` is not a finding
+    // while `packages/cli`'s identical line is.
+    expect(
+      publishBlockers({
+        manifests: [
+          { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] },
+          {
+            name: 'stack',
+            version: '1.0.0',
+            private: false,
+            workspaceDeps: [
+              { table: 'devDependencies', name: EQL, spec: 'workspace:^' },
+            ],
+          },
+        ],
+        lookup: (name) => (name === EQL ? ['3.0.4'] : ['1.0.0']),
+        frozen: new Map(),
+      }),
+    ).toEqual([])
+  })
+
+  it('does not check a private package’s own dependencies', () => {
+    // `examples/*`, `e2e` and `packages/bench` are never packed, so their
+    // `workspace:*` lines reach no consumer.
+    expect(
+      publishBlockers({
+        manifests: [
+          {
+            name: 'test-kit',
+            version: '0.0.1',
+            private: true,
+            workspaceDeps: [],
+          },
+          {
+            name: 'bench',
+            version: '0.0.5',
+            private: true,
+            workspaceDeps: [
+              { table: 'dependencies', name: 'test-kit', spec: 'workspace:*' },
+            ],
+          },
+        ],
+        lookup: empty,
+        frozen: new Map(),
+      }),
+    ).toEqual([])
+  })
+
+  it('propagates a lookup error instead of reporting "nothing blocks"', () => {
+    // The load-bearing direction, same as `unpublished`'s. A network, auth or
+    // rate-limit failure must stop the gate — swallowed, it reads as "this
+    // frozen package is already on npm", which is the one answer that lets the
+    // broken release through.
+    //
+    // The manifest carries a FROZEN package deliberately: that is what makes
+    // the registry answer load-bearing here. A package nothing asks about is
+    // not looked up at all, and `[]` is then the right answer whatever the
+    // registry is doing — so asserting the throw on that shape would pin an
+    // eager round trip rather than the property.
+    expect(() =>
+      publishBlockers({
+        manifests: [
+          { name: EQL, version: '3.0.5', private: false, workspaceDeps: [] },
+        ],
+        lookup: () => {
+          throw new Error('npm view failed: ETIMEDOUT')
+        },
+        frozen: new Map([[EQL, 'publisher not repointed yet']]),
+      }),
+    ).toThrow(/ETIMEDOUT/)
+  })
+})
+
+describe('the gate over this repo’s real manifests', () => {
+  // A SYNTHETIC REGISTRY over the REAL tree: every workspace package is
+  // published at exactly the version the tree carries, EXCEPT `@cipherstash/eql`
+  // — stuck at 3.0.4, which is npm's actual state. So the only thing this can
+  // report is the consequence of the hand-applied 3.0.5 bump, and it reports it
+  // from the manifests themselves rather than from a fixture that could drift
+  // away from them.
+  const manifests = workspaceManifests()
+  const lookup = (name) => {
+    if (name === EQL) return ['3.0.3', '3.0.4']
+    const found = manifests.find((m) => m.name === name)
+    return found ? [found.version] : null
+  }
+  const blockers = publishBlockers({ manifests, lookup })
+
+  it('names the frozen package that cannot publish', () => {
+    expect(
+      blockers
+        .filter((b) => b.kind === 'frozen-publisher')
+        .map((b) => `${b.package}@${b.version}`),
+    ).toEqual([`${EQL}@3.0.5`])
+  })
+
+  it('names every published package that would ship the unsatisfiable range', () => {
+    // THE REGRESSION. `packages/cli` (`stash`) and `packages/stack-prisma` both
+    // carry `"@cipherstash/eql": "workspace:^"` under `dependencies`, so both
+    // pack `^3.0.5`. `packages/stack` carries the same line under
+    // `devDependencies` and must NOT appear.
+    expect(
+      blockers
+        .filter((b) => b.kind === 'frozen-dependency')
+        .map((b) => `${b.package} -> ${b.dependency}@${b.range}`)
+        .sort(),
+    ).toEqual([
+      `@cipherstash/stack-prisma -> ${EQL}@^3.0.5`,
+      `stash -> ${EQL}@^3.0.5`,
+    ])
+  })
+
+  it('reports nothing once the frozen package is on npm at its committed version', () => {
+    // The exit condition, stated as a test: complete the Phase-5 repoint and
+    // publish 3.0.5, and this gate goes quiet on its own. Nothing else has to
+    // change — which is what makes the freeze a fact about the registry rather
+    // than a policy encoded here.
+    expect(
+      publishBlockers({
+        manifests,
+        lookup: (name) => (name === EQL ? ['3.0.4', '3.0.5'] : lookup(name)),
+      }),
+    ).toEqual([])
+  })
+})
+
+describe('the gate actually blocks the publish', () => {
+  const workflow = readWorkflow('.github/workflows/release.yml')
+
+  it('skips the release job unless the gate job succeeded', () => {
+    // A gate that exits non-zero and stops nothing is a slower way of printing
+    // a warning. `release` is the job that runs `changeset publish`, and its
+    // condition is `always()` — needed, because `publish-ffi` is legitimately
+    // skipped — so "gate failed" has to be excluded EXPLICITLY or `always()`
+    // runs the publish straight through the failure.
+    const release = workflow.jobs.release
+    expect(release.needs).toContain('gate')
+    expect(
+      String(release.if),
+      "release.yml's `release` job must require `needs.gate.result == 'success'`. Under " +
+        '`always()` a failed gate would otherwise still reach `changeset publish`.',
+    ).toMatch(/needs\.gate\.result\s*==\s*'success'/)
+  })
+})
+
+/**
+ * The gate as a PROCESS, driven against a fake registry.
+ *
+ * Every test above calls `publishBlockers` and reads what it returns. That
+ * proves the analysis and nothing about the release: a `main()` that computed
+ * the same list and exited 0 would pass all of them while publishing the broken
+ * tarballs. The exit code is the entire mechanism — `release.yml`'s `release`
+ * job is conditioned on `needs.gate.result == 'success'` — so it gets a test
+ * that actually runs the script.
+ *
+ * `npm` is shimmed on PATH rather than the module being imported, because
+ * `npmVersions` shells out to it. That also keeps this offline and
+ * deterministic: the real registry would make the assertion below depend on
+ * whether Phase 5 has happened yet.
+ */
+describe('the gate exits non-zero when a blocker is found', () => {
+  const manifests = workspaceManifests()
+
+  /** A PATH entry whose `npm view <name> versions --json` answers from `map`. */
+  const fakeRegistry = (map) => {
+    const dir = mkdtempSync(join(tmpdir(), 'release-gate-'))
+    const versions = join(dir, 'versions.json')
+    writeFileSync(versions, JSON.stringify(map))
+    const shim = join(dir, 'npm')
+    writeFileSync(
+      shim,
+      '#!/usr/bin/env node\n' +
+        "const map = JSON.parse(require('node:fs').readFileSync(process.env.FAKE_NPM_VERSIONS, 'utf8'))\n" +
+        'const found = map[process.argv[3]]\n' +
+        "if (!found) { process.stderr.write('npm error code E404\\n'); process.exit(1) }\n" +
+        'process.stdout.write(JSON.stringify(found))\n',
+    )
+    chmodSync(shim, 0o755)
+    return { dir, versions }
+  }
+
+  /** Every workspace package published at exactly its committed version. */
+  const allPublished = Object.fromEntries(
+    manifests.map(({ name, version }) => [name, [version]]),
+  )
+
+  const runGate = (map) => {
+    const { dir, versions } = fakeRegistry(map)
+    const result = spawnSync(process.execPath, ['scripts/release-gate.mjs'], {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        PATH: `${dir}:${process.env.PATH}`,
+        FAKE_NPM_VERSIONS: versions,
+        // The real one would be written for the whole vitest run.
+        GITHUB_OUTPUT: join(dir, 'github-output.txt'),
+      },
+    })
+    rmSync(dir, { recursive: true, force: true })
+    return result
+  }
+
+  it('fails the job, and says how to clear it', () => {
+    // TODAY'S TREE against TODAY'S REGISTRY: @cipherstash/eql pinned to 3.0.4,
+    // everything else current. Exit 1 is what skips the `release` job.
+    const result = runGate({ ...allPublished, [EQL]: ['3.0.3', '3.0.4'] })
+    expect(result.status).toBe(1)
+    expect(result.stderr).toContain('cannot be installed')
+    expect(result.stderr).toContain(`${EQL}@3.0.5`)
+    // The message has to name the way out, or a blocked release is a puzzle.
+    expect(result.stderr).toContain('Phase 5')
+  })
+
+  it('still reports the publish set on the run it blocks', () => {
+    // The `ffi`/`js` outputs are diagnostic and are written BEFORE the exit, so
+    // the job log on a blocked run still says what was missing. Losing that
+    // would make the blocked run less informative than a passing one.
+    const result = runGate({ ...allPublished, [EQL]: ['3.0.3', '3.0.4'] })
+    expect(result.stdout).toContain(`unpublished: ${EQL}`)
+  })
+
+  it('exits 0 once the frozen package is published', () => {
+    // The other half of the mutation check: this must not be a gate that always
+    // fails. Publish 3.0.5 and the same tree passes untouched.
+    const result = runGate({ ...allPublished, [EQL]: ['3.0.4', '3.0.5'] })
+    expect(result.stderr).toBe('')
+    expect(result.status).toBe(0)
+  })
+})
diff --git a/scripts/__tests__/release-version-hook.test.mjs b/scripts/__tests__/release-version-hook.test.mjs
index fe6a8cbd4..9ec564197 100644
--- a/scripts/__tests__/release-version-hook.test.mjs
+++ b/scripts/__tests__/release-version-hook.test.mjs
@@ -104,3 +104,69 @@ describe('the root `version` script chains the propagation', () => {
     ).toBeLessThan(script.indexOf(VERSION_SCRIPT))
   })
 })
+
+/**
+ * The same hook, reached the way a human reaches it.
+ *
+ * `release.yml` is not the only caller. `AGENTS.md` documents the release flow
+ * as `pnpm changeset:version`, and that alias was a bare `changeset version` —
+ * so a maintainer following this repo's own documentation reproduced exactly
+ * the skew the hook exists to prevent: npm bumped, the crate and the bundled
+ * SQL left behind. The workflow test above passes throughout, because the
+ * workflow is not what ran.
+ *
+ * The rule is stated over the SCRIPTS rather than over the one name, so a
+ * second convenience alias added later is held to it without anyone
+ * remembering this file exists. Two changeset commands are wrapped by this
+ * repo, and both wrappers are load-bearing:
+ *
+ *   * `changeset version` must chain `sync-lockstep-versions.mjs`, or the
+ *     lockstep bump reaches npm and nothing else.
+ *   * `changeset publish` must build first, or it packs whatever `dist/` the
+ *     working tree happens to hold — which for a clean clone is nothing.
+ *
+ * A script that wraps neither (`pnpm run version`, `pnpm run release`) is not
+ * matched and needs no exemption: it does not contain the bare command.
+ */
+describe('no root script invokes a bare changesets command', () => {
+  const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8'))
+  const scripts = Object.entries(pkg.scripts ?? {})
+
+  /** Scripts whose body runs `changeset <command>`, other than via `pnpm run`. */
+  const invoking = (command) =>
+    scripts.filter(([, body]) =>
+      new RegExp(`(^|[\\s;&|(])changeset\\s+${command}\\b`).test(body),
+    )
+
+  it('finds the wrappers it is checking', () => {
+    // The floor. Both rules below are "for every script that runs X…", and a
+    // repo where nothing matches passes them having checked nothing — which is
+    // also what a rename of the changesets CLI would produce.
+    expect(invoking('version').length).toBeGreaterThan(0)
+    expect(invoking('publish').length).toBeGreaterThan(0)
+  })
+
+  it('chains the lockstep sync onto every `changeset version`', () => {
+    const offenders = invoking('version')
+      .filter(([, body]) => !body.includes(VERSION_SCRIPT))
+      .map(([name, body]) => `${name}: ${body}`)
+    expect(
+      offenders,
+      `A root script runs \`changeset version\` without ${VERSION_SCRIPT}. It bumps the npm ` +
+        'package and leaves packages/eql/crates/eql-bindings/Cargo.toml, every Cargo.lock that ' +
+        'records it, and the bundled SQL at the previous version. Route the alias through ' +
+        '`pnpm run version` instead of calling the changesets CLI directly.',
+    ).toEqual([])
+  })
+
+  it('builds before every `changeset publish`', () => {
+    const offenders = invoking('publish')
+      .filter(([, body]) => !/\brun build\b/.test(body))
+      .map(([name, body]) => `${name}: ${body}`)
+    expect(
+      offenders,
+      'A root script runs `changeset publish` without building first, so it packs whatever ' +
+        '`dist/` the working tree happens to hold. Route the alias through `pnpm run release`.',
+    ).toEqual([])
+  })
+})
diff --git a/scripts/__tests__/sync-lockstep-versions.test.mjs b/scripts/__tests__/sync-lockstep-versions.test.mjs
index 2d4192c61..edd6fbb4d 100644
--- a/scripts/__tests__/sync-lockstep-versions.test.mjs
+++ b/scripts/__tests__/sync-lockstep-versions.test.mjs
@@ -1,5 +1,11 @@
 import { describe, expect, test } from 'vitest'
-import { bumpCargoPackageVersion } from '../sync-lockstep-versions.mjs'
+import {
+  bumpCargoPackageVersion,
+  cargoLockWorkspaces,
+  LOCKED_CRATE,
+  refreshCargoLock,
+} from '../sync-lockstep-versions.mjs'
+import { REPO_ROOT } from './lib/repo-root.mjs'
 
 const CARGO = `[package]
 name = "eql-bindings"
@@ -56,3 +62,80 @@ serde_json = "1"
     expect(out).toContain('serde_json = "1"')
   })
 })
+
+/**
+ * The second thing the lockstep bump has to carry, and the one it did not.
+ *
+ * Rewriting `packages/eql/crates/eql-bindings/Cargo.toml` moves the crate's
+ * version. Every `Cargo.lock` that resolves that crate FROM A PATH records the
+ * old one, and nothing in this repo passes `--locked`, so the stale lock is
+ * regenerated on every CI run, used, and discarded — green the whole way.
+ * `cargo metadata --locked` in `packages/protect-ffi` exited 101 for exactly
+ * this reason after the 3.0.5 bump.
+ *
+ * `scripts/__tests__/cargo-lock-freshness.test.mjs` is the guard that fails a
+ * PR carrying a stale lock. These are the tests for the half that stops it
+ * going stale in the first place.
+ */
+describe('lockstep Cargo.lock refresh', () => {
+  test('discovers every lock that resolves the crate from this tree', () => {
+    const found = cargoLockWorkspaces(REPO_ROOT)
+
+    // The floor. Discovery over a hardcoded list means a walk that stops
+    // matching refreshes nothing and reports success — so an empty result is a
+    // failure, not a no-op. `packages/protect-ffi` is named because it is the
+    // consumer that broke: it path-depends on the crate from a SEPARATE cargo
+    // workspace, so no eql-side build ever touches its lock.
+    expect(found.length).toBeGreaterThan(0)
+    expect(found).toContain('packages/protect-ffi')
+  })
+
+  test('refreshes offline, through mise, against the named workspace', () => {
+    const calls = []
+    refreshCargoLock({
+      root: '/repo',
+      eqlRoot: '/repo/packages/eql',
+      workspace: 'packages/protect-ffi',
+      run: (...args) => calls.push(args),
+    })
+
+    expect(calls).toHaveLength(1)
+    const [command, args, options] = calls[0]
+
+    // THROUGH MISE, not a bare `cargo`. release.yml installs mise with
+    // `add_shims_to_path: false` — deliberately, so mise's own Node cannot
+    // shadow the one `changeset publish` needs — which means cargo is NOT on
+    // PATH in the release job. `mise exec` resolves it from
+    // packages/eql/mise.toml's `[tools] rust`, which is the same toolchain the
+    // SQL build below uses.
+    expect(command).toBe('mise')
+    expect(args.slice(0, 3)).toEqual(['exec', '--', 'cargo'])
+    expect(options.cwd).toBe('/repo/packages/eql')
+
+    // OFFLINE. This runs inside `changeset version`, between the manifest
+    // rewrite and the commit; a registry fetch there is a network dependency
+    // on the release path buying nothing, because the crate resolves from a
+    // path. Verified byte-identical to the networked resolution.
+    expect(args).toContain('--offline')
+    expect(args).toContain('--package')
+    expect(args).toContain(LOCKED_CRATE)
+    expect(args).toContain('--manifest-path')
+    expect(args).toContain('/repo/packages/protect-ffi/Cargo.toml')
+  })
+
+  test('fails loudly rather than leaving a lock stale', () => {
+    // A refresh that cannot run must stop the release. The alternative is the
+    // state this whole pair of tests exists to end: a bumped manifest, a lock
+    // that still names the old version, and a green log.
+    expect(() =>
+      refreshCargoLock({
+        root: '/repo',
+        eqlRoot: '/repo/packages/eql',
+        workspace: 'packages/protect-ffi',
+        run: () => {
+          throw new Error('spawn mise ENOENT')
+        },
+      }),
+    ).toThrow(/ENOENT/)
+  })
+})
diff --git a/scripts/__tests__/workflow-mise-setup.test.mjs b/scripts/__tests__/workflow-mise-setup.test.mjs
new file mode 100644
index 000000000..e8489691f
--- /dev/null
+++ b/scripts/__tests__/workflow-mise-setup.test.mjs
@@ -0,0 +1,235 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { REPO_ROOT } from './lib/repo-root.mjs'
+import { readWorkflow, workflowFiles } from './lib/workflows.mjs'
+
+/**
+ * A job whose command chain reaches `mise` must install mise, first.
+ *
+ * ## Why this fails open, and silently, without a test
+ *
+ * `mise` is NOT preinstalled on GitHub's ubuntu runner images. A job that needs
+ * it and does not install it fails with `ENOENT: spawn mise` — which is loud
+ * enough, once it runs. The problem is *when* it runs.
+ *
+ * `release.yml`'s `release` job passes `version: pnpm run version` to
+ * `changesets/action`. That input is a shell command, and the chain behind it
+ * is three hops deep and entirely invisible in the workflow file:
+ *
+ *     version: pnpm run version                       (release.yml)
+ *       -> "changeset version && node scripts/sync-lockstep-versions.mjs"
+ *                                                     (root package.json)
+ *          -> execFileSync('mise', ['run', 'release:prepare_bindings_assets'…])
+ *                                                     (that script)
+ *
+ * Nothing in `release.yml` says the word `mise`. The job installed pnpm, Node,
+ * node-gyp and npm and looked complete. And the branch that runs the hook —
+ * changesets taking its VERSION branch, which it does only when `.changeset/`
+ * holds unconsumed changesets — is not the branch a release rehearsal
+ * exercises, so the gap survived review of both the workflow and the script.
+ *
+ * The cost of finding out at run time is what makes this a test rather than a
+ * comment: `changeset version` runs FIRST and rewrites every manifest and
+ * changelog in the tree. The ENOENT lands after that, so the failure is a
+ * half-applied version bump in a job holding `contents: write`, and the repair
+ * is manual.
+ *
+ * ## What is checked
+ *
+ * The chain is RESOLVED, not pattern-matched, because the whole defect is that
+ * the requirement is not visible at the call site. `pnpm run <script>` is
+ * followed into the root `package.json`, `node <path>.mjs` into the file, and
+ * `child_process` spawns inside those files are read for the binary they
+ * launch. A job that reaches `mise` by any of those routes must carry a mise
+ * setup step, at a lower step index than the step that needs it.
+ *
+ * ## Why `mise` and not also `cargo`
+ *
+ * The runner images DO ship a Rust toolchain, and this repo relies on that:
+ * `.github/actions/build-ffi-binding` runs `cargo build --release` with no
+ * toolchain step of its own. Requiring a Rust setup step wherever cargo is
+ * reachable would report every one of those as a finding. mise is the tool that
+ * is genuinely absent — and, for the EQL tasks, the thing that supplies cargo
+ * anyway (`packages/eql/mise.toml` pins `rust` under `[tools]`).
+ */
+
+/**
+ * Action inputs whose value is a shell command rather than data.
+ *
+ * Hand-listed because there is no way to tell from the outside: `version:` on
+ * `changesets/action` is a command, `version:` on `jdx/mise-action` is a
+ * version number. The floor below fails if an entry here matches no step, so a
+ * renamed input cannot leave this silently covering nothing.
+ */
+const ACTION_COMMAND_INPUTS = new Map([
+  ['changesets/action', ['version', 'publish']],
+])
+
+/** A `uses:` value reduced to its `owner/repo` half, lowercased. */
+const actionPath = (uses) =>
+  typeof uses === 'string' ? uses.trim().split('@')[0].toLowerCase() : null
+
+/** Steps that put `mise` on PATH for everything after them. */
+const isMiseSetup = (step) => actionPath(step?.uses) === 'jdx/mise-action'
+
+/** Every shell command a step runs — its `run:`, plus any command-valued input. */
+function stepCommands(step) {
+  const commands = []
+  if (typeof step?.run === 'string') commands.push(step.run)
+  for (const input of ACTION_COMMAND_INPUTS.get(actionPath(step?.uses)) ?? []) {
+    const value = step?.with?.[input]
+    if (typeof value === 'string') commands.push(value)
+  }
+  return commands
+}
+
+const ROOT_SCRIPTS =
+  JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8')).scripts ??
+  {}
+
+/**
+ * `pnpm run x` / `npm run x` / `pnpm x` / `yarn x`.
+ *
+ * A capture that is not a root script name resolves to nothing and is dropped,
+ * which is what happens to `pnpm install`, `pnpm exec …` and the `--filter`
+ * forms. Package-level scripts are deliberately not followed: no workflow input
+ * reaches `mise` that way today, and resolving them would mean modelling
+ * `--filter` selection.
+ */
+const RUN_SCRIPT =
+  /(?:^|[\s;&|(])(?:pnpm|npm|yarn)(?:\s+run)?\s+([a-z0-9:_-]+)/gi
+
+/** `node path/to/file.mjs`, with any `node` flags in between. */
+const NODE_SCRIPT = /\bnode\s+(?:--?[^\s]+\s+)*([\w./-]+\.[cm]?js)\b/g
+
+/**
+ * The first argument of a `node:child_process` spawn, as a literal.
+ *
+ * Both shapes matter and they read differently: `execFileSync('mise', [...])`
+ * names the binary alone, while `execSync('mise run build')` is a whole shell
+ * line. `commandLaunchesMise` below accepts either.
+ */
+const CHILD_PROCESS_SPAWN =
+  /\b(?:execSync|exec|execFileSync|execFile|spawnSync|spawn)\s*\(\s*(['"`])([^'"`]*)\1/g
+
+/** Does this shell line invoke `mise` as a command? */
+const invokesMise = (command) => /(?:^|[\s;&|(])mise(?:\s|$)/.test(command)
+
+/**
+ * Whether a shell command reaches `mise`, following package scripts and the
+ * Node scripts they run.
+ *
+ * `seen` spans the whole walk so a script pair that references each other
+ * terminates, and so a script reached twice is read once.
+ */
+function reachesMise(command, seen = new Set()) {
+  if (typeof command !== 'string' || seen.has(command)) return false
+  seen.add(command)
+  if (invokesMise(command)) return true
+
+  for (const [, name] of command.matchAll(RUN_SCRIPT)) {
+    if (ROOT_SCRIPTS[name] && reachesMise(ROOT_SCRIPTS[name], seen)) return true
+  }
+  for (const [, relative] of command.matchAll(NODE_SCRIPT)) {
+    if (fileReachesMise(relative, seen)) return true
+  }
+  return false
+}
+
+/** The same question, of a JavaScript file this repo owns. */
+function fileReachesMise(relative, seen) {
+  const file = join(REPO_ROOT, relative)
+  if (seen.has(file) || !existsSync(file)) return false
+  seen.add(file)
+
+  const source = readFileSync(file, 'utf8')
+  for (const [, , launched] of source.matchAll(CHILD_PROCESS_SPAWN)) {
+    if (launched === 'mise' || invokesMise(launched)) return true
+  }
+  // A script that runs another script. Same walk, one level down.
+  for (const [, nested] of source.matchAll(NODE_SCRIPT)) {
+    if (fileReachesMise(nested, seen)) return true
+  }
+  return false
+}
+
+/** Every job in the workflow directory, with its steps. */
+const JOBS = workflowFiles().flatMap((file) => {
+  const doc = readWorkflow(file)
+  return Object.entries(doc?.jobs ?? {}).map(([name, job]) => ({
+    id: `${file} / ${name}`,
+    steps: Array.isArray(job?.steps) ? job.steps : [],
+  }))
+})
+
+/** `{ id, needsAt, setupAt }` for every job whose chain reaches mise. */
+const MISE_JOBS = JOBS.map(({ id, steps }) => {
+  const needsAt = steps.findIndex((step) =>
+    stepCommands(step).some((command) => reachesMise(command)),
+  )
+  const setupAt = steps.findIndex(isMiseSetup)
+  return { id, needsAt, setupAt }
+}).filter(({ needsAt }) => needsAt !== -1)
+
+describe('a job that reaches mise installs mise', () => {
+  it('resolves the release hook’s chain, which names mise nowhere it is called', () => {
+    // THE MECHANISM, pinned directly. Every assertion below is "for each job
+    // whose chain reaches mise…", and a resolver that quietly stopped following
+    // `pnpm run` or `node …` would make that set empty and every one of them
+    // pass having checked nothing. This is the chain the defect lived in, so it
+    // is the one worth pinning: three hops, no `mise` token at the call site.
+    expect(reachesMise('pnpm run version')).toBe(true)
+    // …and the resolver is not simply answering true. A root script with no
+    // mise anywhere behind it must come back false.
+    expect(reachesMise('pnpm run code:check')).toBe(false)
+  })
+
+  it('finds jobs to check', () => {
+    // The floor. This whole file is a discovery scan, and a scan that matches
+    // nothing exits green — the failure mode `lint-no-eql-registry-pins.mjs`
+    // spends a page of its header on.
+    expect(MISE_JOBS.length).toBeGreaterThan(0)
+  })
+
+  it('matches every command-valued action input against a real step', () => {
+    // ACTION_COMMAND_INPUTS is hand-maintained, so it goes stale silently: an
+    // input renamed upstream leaves an entry that reads as coverage and follows
+    // nothing. Require each key to name an action a step actually uses.
+    const used = new Set(
+      JOBS.flatMap(({ steps }) => steps.map((step) => actionPath(step?.uses))),
+    )
+    expect(
+      [...ACTION_COMMAND_INPUTS.keys()].filter((action) => !used.has(action)),
+      'ACTION_COMMAND_INPUTS names an action no workflow step uses — its command inputs are followed nowhere.',
+    ).toEqual([])
+  })
+
+  it('installs mise in every job that reaches it', () => {
+    // The defect. `release.yml`'s `release` job runs the lockstep version hook
+    // through `changesets/action`'s `version:` input and installed no mise, so
+    // the first push to main with unconsumed changesets would rewrite every
+    // manifest and then die on ENOENT.
+    const offenders = MISE_JOBS.filter(({ setupAt }) => setupAt === -1).map(
+      ({ id }) => id,
+    )
+    expect(
+      offenders,
+      'These jobs run a command whose chain shells out to `mise`, which is not preinstalled on ' +
+        "GitHub's runner images. Add a `jdx/mise-action` step — with `working_directory:` set to " +
+        'the directory holding the `mise.toml` the task needs, or mise will not trust it.',
+    ).toEqual([])
+  })
+
+  it('installs mise before the step that needs it', () => {
+    // PATH is set for SUBSEQUENT steps, so a setup step that lands after the
+    // step needing it is the same failure with a passing existence check.
+    const offenders = MISE_JOBS.filter(
+      ({ needsAt, setupAt }) => setupAt !== -1 && setupAt > needsAt,
+    ).map(
+      ({ id, needsAt, setupAt }) =>
+        `${id}: needs at ${needsAt}, installs at ${setupAt}`,
+    )
+    expect(offenders).toEqual([])
+  })
+})
diff --git a/scripts/release-gate.mjs b/scripts/release-gate.mjs
index d6a3c3abf..d8068e809 100644
--- a/scripts/release-gate.mjs
+++ b/scripts/release-gate.mjs
@@ -17,6 +17,22 @@
  *
  * So every failure mode here fails loudly: a lookup that errors for any reason
  * other than a 404 throws rather than being read as "already published".
+ *
+ * ## The second half: what must NOT be published
+ *
+ * The gate above answers "what is missing from npm". `publishBlockers` answers
+ * the question that arrives with it — whether publishing that set produces
+ * something installable — and it EXITS NON-ZERO, which is what stops the
+ * release. `release.yml`'s `release` job requires `needs.gate.result ==
+ * 'success'`, so a blocker here means `changeset publish` is never reached.
+ *
+ * It exists because `changeset publish` has no idea. In the installed 2.31.0 it
+ * filters `packages.filter(pkg => !pkg.packageJson.private)`, asks npm which of
+ * those versions are missing, and publishes them with `Promise.all` — no
+ * dependency ordering — while `publishAPackage` RETURNS a failure rather than
+ * throwing it. So a package that cannot publish does not abort the release; it
+ * simply does not arrive, and every sibling that depends on it ships anyway,
+ * pointing at a version nobody can install.
  */
 import { execFileSync } from 'node:child_process'
 import { appendFileSync, globSync, readFileSync } from 'node:fs'
@@ -59,6 +75,330 @@ export function classify(names) {
   }
 }
 
+/** pnpm's in-workspace dependency protocol. */
+const WORKSPACE_PROTOCOL = 'workspace:'
+
+/** Every table a `workspace:` specifier can appear in. */
+const DEPENDENCY_TABLES = [
+  'dependencies',
+  'devDependencies',
+  'optionalDependencies',
+  'peerDependencies',
+]
+
+/**
+ * The tables a CONSUMER of the published tarball installs from.
+ *
+ * `devDependencies` is deliberately absent. pnpm rewrites the `workspace:`
+ * specifier there too, and the rewritten range does ship inside the packed
+ * `package.json` — but nothing installing the package ever resolves it, so an
+ * unsatisfiable one breaks nobody. That asymmetry is live in this tree:
+ * `packages/stack` declares `"@cipherstash/eql": "workspace:^"` under
+ * devDependencies and is not a finding, while `packages/cli` and
+ * `packages/stack-prisma` declare the identical line under `dependencies` and
+ * are.
+ */
+const INSTALLED_TABLES = new Set([
+  'dependencies',
+  'optionalDependencies',
+  'peerDependencies',
+])
+
+/**
+ * Packages that live in this repository but are NOT published from it, each
+ * with the reason.
+ *
+ * WHY THIS CANNOT BE DERIVED. npm trusted publishing binds a package to a
+ * repository and a workflow filename, and the registry exposes no way to ask
+ * "would a publish from here be accepted?" — the provenance attestation on the
+ * LAST release names the repository that made it, which is evidence about the
+ * past, not permission for the next one. So the fact has to be written down,
+ * and the cost of it being wrong is a release that half-publishes. Hence: one
+ * entry per package, with the reason a later reader needs in order to decide
+ * whether it is still true, in the shape of `EXEMPT_DECLARATIONS` in
+ * `scripts/lint-no-eql-registry-pins.mjs`.
+ *
+ * Each entry is DELETED by the cutover that repoints its publisher — the same
+ * PR that deletes `scripts/lint-no-ffi-changeset.mjs` for the seven FFI ones
+ * (phase 4), and the Phase-5 release cutover for EQL. Leaving one behind is not
+ * silent: the package keeps releasing at a version already on npm, so the
+ * frozen check keeps passing, and the FIRST bump after the cutover blocks a
+ * release that would have worked. Loud, and at the moment someone is looking.
+ */
+export const FROZEN_PUBLISHERS = new Map([
+  [
+    '@cipherstash/eql',
+    'Still published from cipherstash/encrypt-query-language — the npm provenance on ' +
+      '3.0.4 names that repository and `release.yml` here carries no NPM_TOKEN. Repointing ' +
+      'is Phase 5 of docs/plans/2026-08-13-eql-monorepo-absorption.md.',
+  ],
+  ...[
+    '@cipherstash/protect-ffi',
+    '@cipherstash/protect-ffi-darwin-x64',
+    '@cipherstash/protect-ffi-darwin-arm64',
+    '@cipherstash/protect-ffi-win32-x64-msvc',
+    '@cipherstash/protect-ffi-linux-x64-gnu',
+    '@cipherstash/protect-ffi-linux-arm64-gnu',
+    '@cipherstash/protect-ffi-linux-x64-musl',
+  ].map((name) => [
+    name,
+    'Still published from cipherstash/protectjs-ffi until npm trusted publishing is ' +
+      'repointed (the phase-4 cutover). `scripts/lint-no-ffi-changeset.mjs` keeps all seven ' +
+      'at their published version so `changeset publish` skips them; this is that ' +
+      'assumption checked rather than assumed, which is what the EQL bump showed it needed.',
+  ]),
+])
+
+/**
+ * The range pnpm writes into the packed `package.json` for a `workspace:`
+ * specifier.
+ *
+ * `workspace:*` is the one worth reading twice: it becomes the dependency's
+ * EXACT version, not a wildcard. That is what makes an unpublished workspace
+ * dependency unsatisfiable rather than merely loose.
+ *
+ * Returns `null` for anything that is not the workspace protocol — a registry
+ * range is npm's problem, not this gate's.
+ */
+export function packedRange(spec, version) {
+  if (typeof spec !== 'string' || !spec.startsWith(WORKSPACE_PROTOCOL)) {
+    return null
+  }
+  const rest = spec.slice(WORKSPACE_PROTOCOL.length)
+  if (rest === '*') return version
+  if (rest === '^' || rest === '~') return `${rest}${version}`
+  if (rest === '') {
+    throw new Error(`\`${spec}\` names no version and no alias`)
+  }
+  return rest
+}
+
+const VERSION =
+  /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
+
+function parseVersion(text) {
+  const match = VERSION.exec(String(text).trim())
+  if (!match) return null
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    pre: match[4] ?? null,
+  }
+}
+
+/** semver precedence for the prerelease field. A release outranks its prereleases. */
+function comparePrerelease(a, b) {
+  if (a === b) return 0
+  if (a === null) return 1
+  if (b === null) return -1
+  const left = a.split('.')
+  const right = b.split('.')
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const x = left[i]
+    const y = right[i]
+    if (x === undefined) return -1
+    if (y === undefined) return 1
+    const xNumeric = /^\d+$/.test(x)
+    const yNumeric = /^\d+$/.test(y)
+    if (xNumeric && yNumeric) {
+      if (Number(x) !== Number(y)) return Number(x) < Number(y) ? -1 : 1
+      continue
+    }
+    if (xNumeric !== yNumeric) return xNumeric ? -1 : 1
+    if (x !== y) return x < y ? -1 : 1
+  }
+  return 0
+}
+
+function compareVersions(a, b) {
+  for (const field of ['major', 'minor', 'patch']) {
+    if (a[field] !== b[field]) return a[field] < b[field] ? -1 : 1
+  }
+  return comparePrerelease(a.pre, b.pre)
+}
+
+/** The exclusive upper bound of `^v` — the 0.x and 0.0.x narrowings included. */
+function caretBound({ major, minor, patch }) {
+  if (major > 0) return { major: major + 1, minor: 0, patch: 0, pre: null }
+  if (minor > 0) return { major: 0, minor: minor + 1, patch: 0, pre: null }
+  return { major: 0, minor: 0, patch: patch + 1, pre: null }
+}
+
+const RANGE =
+  /^(\^|~)?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/
+
+/**
+ * Whether `version` satisfies `range`, for the range shapes `packedRange` can
+ * produce.
+ *
+ * WRITTEN OUT RATHER THAN DEPENDED ON, for the reason in the `NODE BUILTINS
+ * ONLY` note below: this file runs in a job with no `node_modules`, and adding
+ * `semver` to it would oblige a cold full-workspace install on every push to
+ * main just to compare two version strings.
+ *
+ * The scope is exactly what pnpm writes — an exact pin, `^`, `~`, and `*` —
+ * and ANYTHING ELSE THROWS. A general range parser written by hand is how a
+ * gate quietly starts answering the wrong question; a range this cannot read is
+ * a release that stops until someone extends it, which is the safe direction.
+ *
+ * The prerelease rule is not decoration. npm carries `@cipherstash/eql`
+ * prereleases (`3.0.0-alpha.2`, `3.0.1-alpha.0`, …), and under a naive
+ * comparison some of them fall inside `^3.0.5`'s window — which would report
+ * that range as satisfiable and wave the entire defect through. Per semver, a
+ * prerelease satisfies a range only when the range's own bound is a prerelease
+ * of the same major.minor.patch.
+ */
+export function satisfies(version, range) {
+  const text = String(range).trim()
+  const parsed = parseVersion(version)
+  if (parsed === null) {
+    throw new Error(`unparsable version \`${version}\``)
+  }
+  if (text === '*') return parsed.pre === null
+
+  const match = RANGE.exec(text)
+  if (!match) {
+    throw new Error(
+      `unsupported version range \`${range}\` — this gate reads exact, \`^\`, \`~\` and ` +
+        '`*` only, which is everything pnpm writes for a `workspace:` specifier. Extend ' +
+        '`satisfies` rather than loosening it.',
+    )
+  }
+  const [, operator, bound] = match
+  const lower = parseVersion(bound)
+
+  if (
+    parsed.pre !== null &&
+    !(
+      lower.pre !== null &&
+      parsed.major === lower.major &&
+      parsed.minor === lower.minor &&
+      parsed.patch === lower.patch
+    )
+  ) {
+    return false
+  }
+
+  if (!operator) return compareVersions(parsed, lower) === 0
+  if (compareVersions(parsed, lower) < 0) return false
+  const upper =
+    operator === '^'
+      ? caretBound(lower)
+      : { major: lower.major, minor: lower.minor + 1, patch: 0, pre: null }
+  return compareVersions(parsed, upper) < 0
+}
+
+/**
+ * Everything that must not be published, as data.
+ *
+ * Two checks, one pass. `lookup` is the same injected registry reader
+ * `unpublished` takes, so a failure propagates rather than reading as "nothing
+ * blocks" — the header's rule, applied here too.
+ *
+ * CHECK A — a FROZEN package whose committed version is absent from npm.
+ * `changeset publish` will attempt it (it publishes on registry state alone)
+ * and the attempt is rejected, without stopping anything else.
+ *
+ * CHECK B — a published package's runtime `workspace:` range that no version on
+ * npm satisfies. Three verdicts, and the middle one is what makes this usable:
+ *
+ *   * the dependency is PRIVATE, or the range cannot be satisfied even by the
+ *     workspace's own version (a hand-written `workspace:^2.0.0` on a 1.x
+ *     member) — a blocker either way, since no publish will ever fix it;
+ *   * the dependency is FROZEN — a blocker, because the version that would
+ *     satisfy the range is precisely the one that cannot be published;
+ *   * otherwise the dependency is simply being published in this same release,
+ *     which is EVERY ordinary release of this repo. `@cipherstash/stack-drizzle`
+ *     depends on `@cipherstash/stack` at `workspace:*`, they share a fixed
+ *     group, and at gate time neither is on npm yet. Blocking that would freeze
+ *     the repository permanently while catching nothing.
+ *
+ * THE THIRD VERDICT IS NOT SAFE, IT IS MERELY NOT WORSE. Changesets publishes
+ * with `Promise.all`, so within one release a dependent can reach npm before
+ * its dependency, and for that window an install resolves a range whose target
+ * is not there yet. Nothing here can close it: the gate has no ordering to
+ * check, and refusing the case outright is the freeze above. What it CAN do is
+ * separate the transient window from the permanent hole — a dependency that
+ * cannot publish at all — which is the whole difference between the two, and
+ * the only one either side of it gets wrong in the same direction.
+ */
+export function publishBlockers({
+  manifests,
+  lookup,
+  frozen = FROZEN_PUBLISHERS,
+}) {
+  const cache = new Map()
+  const versionsOf = (name) => {
+    if (!cache.has(name)) cache.set(name, lookup(name))
+    return cache.get(name) ?? []
+  }
+  const byName = new Map(manifests.map((manifest) => [manifest.name, manifest]))
+  const published = manifests.filter((manifest) => !manifest.private)
+  const blockers = []
+
+  for (const { name, version } of published) {
+    if (frozen.has(name) && !versionsOf(name).includes(version)) {
+      blockers.push({
+        kind: 'frozen-publisher',
+        package: name,
+        version,
+        reason: frozen.get(name),
+      })
+    }
+  }
+
+  for (const manifest of published) {
+    for (const dep of manifest.workspaceDeps ?? []) {
+      if (!INSTALLED_TABLES.has(dep.table)) continue
+
+      const target = byName.get(dep.name)
+      if (!target) {
+        // pnpm cannot resolve this at pack time either, but it is worth a
+        // verdict of its own rather than an unhandled throw below.
+        blockers.push({
+          kind: 'unknown-workspace-dependency',
+          package: manifest.name,
+          dependency: dep.name,
+          table: dep.table,
+        })
+        continue
+      }
+
+      const range = packedRange(dep.spec, target.version)
+      const finding = {
+        package: manifest.name,
+        dependency: dep.name,
+        table: dep.table,
+        range,
+      }
+
+      if (!satisfies(target.version, range)) {
+        blockers.push({ ...finding, kind: 'unsatisfiable-range' })
+        continue
+      }
+      if (
+        versionsOf(dep.name).some((candidate) => satisfies(candidate, range))
+      ) {
+        continue
+      }
+      if (target.private) {
+        blockers.push({ ...finding, kind: 'private-dependency' })
+        continue
+      }
+      if (frozen.has(dep.name)) {
+        blockers.push({
+          ...finding,
+          kind: 'frozen-dependency',
+          reason: frozen.get(dep.name),
+        })
+      }
+    }
+  }
+
+  return blockers
+}
+
 /**
  * The `packages:` globs from `pnpm-workspace.yaml`, parsed without a YAML
  * library.
@@ -125,10 +465,24 @@ export function workspaceManifests() {
     .map((relative) =>
       JSON.parse(readFileSync(join(REPO_ROOT, relative), 'utf8')),
     )
-    .map(({ name, version, private: isPrivate }) => ({
-      name,
-      version,
-      private: Boolean(isPrivate),
+    .map((manifest) => ({
+      name: manifest.name,
+      version: manifest.version,
+      private: Boolean(manifest.private),
+      // Carried alongside, not looked up later: `publishBlockers` has to answer
+      // questions about a manifest it was not handed the path to, and the four
+      // tables are read here once rather than re-globbed per dependency.
+      // devDependencies are INCLUDED — `INSTALLED_TABLES` is what narrows them,
+      // and keeping the raw set means the narrowing is a decision the tests can
+      // see rather than an absence they cannot.
+      workspaceDeps: DEPENDENCY_TABLES.flatMap((table) =>
+        Object.entries(manifest[table] ?? {})
+          .filter(
+            ([, spec]) =>
+              typeof spec === 'string' && spec.startsWith(WORKSPACE_PROTOCOL),
+          )
+          .map(([name, spec]) => ({ table, name, spec })),
+      ),
     }))
 
   // Same reasoning as the empty-pattern throw: no manifests is indistinguishable
@@ -161,9 +515,78 @@ export function npmVersions(name) {
   }
 }
 
+/**
+ * A blocker list, turned into the text that explains it.
+ *
+ * Separate and exported so the message itself is testable — it is the entire
+ * product of a failing gate, and a release stopped by a message nobody can act
+ * on is a release stopped twice.
+ */
+export function reportBlockers(blockers) {
+  const lines = blockers.map((blocker) => {
+    switch (blocker.kind) {
+      case 'frozen-publisher':
+        return (
+          `  ${blocker.package}@${blocker.version} is not on npm, and cannot be published ` +
+          `from this repository.\n      ${blocker.reason}`
+        )
+      case 'frozen-dependency':
+        return (
+          `  ${blocker.package} depends on ${blocker.dependency}@${blocker.range} ` +
+          `[${blocker.table}], which no published version satisfies.\n` +
+          `      ${blocker.reason}`
+        )
+      case 'private-dependency':
+        return (
+          `  ${blocker.package} depends on ${blocker.dependency}@${blocker.range} ` +
+          `[${blocker.table}], and that package is private — it has no registry entry at all.`
+        )
+      case 'unsatisfiable-range':
+        return (
+          `  ${blocker.package} declares ${blocker.dependency}@${blocker.range} ` +
+          `[${blocker.table}], which the workspace's own version does not satisfy.`
+        )
+      default:
+        return (
+          `  ${blocker.package} declares a \`workspace:\` dependency on ` +
+          `${blocker.dependency} [${blocker.table}], which is not a workspace member.`
+        )
+    }
+  })
+
+  return (
+    '\nThis release would publish packages that cannot be installed:\n\n' +
+    `${lines.join('\n')}\n\n` +
+    '`changeset publish` will not catch any of this. It publishes every public\n' +
+    'workspace package whose version is absent from npm — changeset or no\n' +
+    'changeset — with no dependency ordering, and a failed publish returns a\n' +
+    'result rather than throwing, so it does not stop the packages that depend\n' +
+    'on it. The tarballs would go out and the failure would surface in a\n' +
+    "consumer's `npm install`.\n\n" +
+    'There are exactly two ways past this, and neither is editing this gate:\n\n' +
+    '  1. Publish the frozen package. For @cipherstash/eql that is the Phase 5\n' +
+    '     cutover in docs/plans/2026-08-13-eql-monorepo-absorption.md: repoint\n' +
+    '     npm trusted publishing to cipherstash/stack, release 3.0.5, and every\n' +
+    '     finding above clears on its own with no further change here.\n' +
+    '  2. Do not release. Reverting the workspace version to the one already on\n' +
+    '     npm also clears it, at the cost of the bump.\n\n' +
+    'Weakening the check is not a third option — the ranges above are what ends\n' +
+    'up in a published tarball either way.\n'
+  )
+}
+
 function main() {
   const manifests = workspaceManifests()
-  const missing = unpublished(manifests, npmVersions)
+  // One cache across both questions: `unpublished` and `publishBlockers` ask
+  // the registry about overlapping sets, and `npm view` is a network round trip
+  // per package in a job that may not cache anything.
+  const cache = new Map()
+  const lookup = (name) => {
+    if (!cache.has(name)) cache.set(name, npmVersions(name))
+    return cache.get(name)
+  }
+
+  const missing = unpublished(manifests, lookup)
   const { ffi, js } = classify(missing)
 
   console.log(
@@ -179,6 +602,19 @@ function main() {
   if (process.env.GITHUB_OUTPUT) {
     appendFileSync(process.env.GITHUB_OUTPUT, `ffi=${ffi}\njs=${js}\n`)
   }
+
+  // AFTER the outputs are written, and before anything acts on them. The
+  // outputs are diagnostic — the job log should still say what was missing even
+  // on the run that refuses to publish it — while the exit code is what
+  // actually stops the release: `release.yml`'s `release` job requires
+  // `needs.gate.result == 'success'`, so a non-zero exit here skips the job
+  // that runs `changeset publish` (and, through the same `needs`, the FFI
+  // matrix). Asserted by scripts/__tests__/release-gate.test.mjs.
+  const blockers = publishBlockers({ manifests, lookup })
+  if (blockers.length > 0) {
+    console.error(reportBlockers(blockers))
+    process.exit(1)
+  }
 }
 
 // Importable without running: the unit tests exercise the two pure functions
diff --git a/scripts/sync-lockstep-versions.mjs b/scripts/sync-lockstep-versions.mjs
index 03e345f4d..b252580db 100644
--- a/scripts/sync-lockstep-versions.mjs
+++ b/scripts/sync-lockstep-versions.mjs
@@ -11,13 +11,22 @@
 // It (paths relative to the monorepo root):
 //   1. reads V from packages/eql/packages/eql/package.json,
 //   2. sets packages/eql/crates/eql-bindings/Cargo.toml [package] version = V,
-//   3. runs `mise run release:prepare_bindings_assets --version V`, which builds
+//   3. re-resolves that crate in every Cargo.lock that records it from a path,
+//   4. runs `mise run release:prepare_bindings_assets --version V`, which builds
 //      the exact-version SQL and writes it (+ release manifests) into both the
 //      crate and the npm package.
+//
+// Step 3 is not decoration. Step 2 moves a version that `packages/protect-ffi`'s
+// SEPARATE cargo workspace has pinned in its own lock, and nothing else updates
+// it — `packages/eql`'s lock is refreshed as a side effect of step 4, that one
+// by nothing at all. Since no command in this repo passes `--locked`, the stale
+// lock is silently regenerated on every CI run and the committed file drifts
+// further out on each bump. `scripts/__tests__/cargo-lock-freshness.test.mjs`
+// fails a PR that carries the drift; step 3 is what stops producing it.
 
 import { execFileSync } from 'node:child_process'
-import { readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative, sep } from 'node:path'
 import process from 'node:process'
 import { fileURLToPath } from 'node:url'
 
@@ -41,6 +50,108 @@ export function bumpCargoPackageVersion(cargo, version) {
   return cargo.replace(packageSection[0], updated)
 }
 
+/** The crate whose version step 2 above moves, and every lock therefore records. */
+export const LOCKED_CRATE = 'eql-bindings'
+
+/** Directories the lock scan does not descend into — same set, same reasons, as
+ * `scripts/lint-no-eql-registry-pins.mjs`. `target` and `node_modules` are the
+ * load-bearing two: both are full of OTHER packages' lockfiles. */
+const SKIP_DIRS = new Set([
+  '.git',
+  'node_modules',
+  'target',
+  'dist',
+  '.turbo',
+  '.next',
+])
+
+/**
+ * Every cargo workspace whose `Cargo.lock` resolves `LOCKED_CRATE` from this
+ * tree, repo-relative.
+ *
+ * DISCOVERED, not listed. The crate is consumed across cargo workspace
+ * boundaries — `packages/protect-ffi/crates/protect-ffi/Cargo.toml` reaches it
+ * by `path = "../../../eql/crates/eql-bindings"` — and a hardcoded list is
+ * exactly what was missing before: `packages/eql`'s own lock is refreshed as a
+ * side effect of the SQL build below, `packages/protect-ffi`'s was refreshed by
+ * nothing, and no one noticed because no command in this repo passes
+ * `--locked`.
+ *
+ * A registry or git dependency carries a `source = "…"` key in the lock; a path
+ * dependency carries none, which is how cargo itself tells them apart and the
+ * only test needed here.
+ */
+export function cargoLockWorkspaces(root) {
+  const found = []
+  const walk = (abs) => {
+    for (const entry of readdirSync(abs, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(join(abs, entry.name))
+        continue
+      }
+      if (entry.name !== 'Cargo.lock') continue
+      const lock = readFileSync(join(abs, entry.name), 'utf8')
+      const records = lock
+        .split(/^\[\[package\]\]$/m)
+        .slice(1)
+        .some(
+          (block) =>
+            new RegExp(`^name = "${LOCKED_CRATE}"$`, 'm').test(block) &&
+            !/^source = "/m.test(block),
+        )
+      if (records) found.push(relative(root, abs).split(sep).join('/'))
+    }
+  }
+  walk(root)
+  return found.sort()
+}
+
+/**
+ * Re-resolve `LOCKED_CRATE` in one workspace's `Cargo.lock`.
+ *
+ * THROUGH `mise exec`, not a bare `cargo`. `release.yml` installs mise with
+ * `add_shims_to_path: false` — deliberately, so mise's Node cannot shadow the
+ * one `changeset publish` shells out to — which leaves cargo off PATH in that
+ * job. `mise exec`, run from the EQL root, resolves it from
+ * `packages/eql/mise.toml`'s `[tools] rust`: the same toolchain that compiles
+ * `eql-codegen` for the SQL build a few lines below, so there is one Rust here
+ * rather than two.
+ *
+ * `--offline` because the crate resolves from a path and needs no registry.
+ * Confirmed byte-identical to the networked resolution on the 3.0.4 -> 3.0.5
+ * bump, including the four unrelated `windows-sys` edges cargo repaired along
+ * the way. A release-time step should not acquire a network dependency it has
+ * no use for.
+ *
+ * `--manifest-path` rather than a second `cwd`, so every cargo invocation in
+ * this script runs from the one directory whose mise config is trusted.
+ *
+ * `run` is injected for the unit tests: what matters is the argv, and asserting
+ * it must not require a Rust toolchain on the machine running `test:scripts`.
+ */
+export function refreshCargoLock({
+  root,
+  eqlRoot,
+  workspace,
+  run = execFileSync,
+}) {
+  run(
+    'mise',
+    [
+      'exec',
+      '--',
+      'cargo',
+      'update',
+      '--offline',
+      '--package',
+      LOCKED_CRATE,
+      '--manifest-path',
+      join(root, workspace, 'Cargo.toml'),
+    ],
+    { cwd: eqlRoot, stdio: 'inherit' },
+  )
+}
+
 function main() {
   // This script lives at the monorepo root (`scripts/`) because Changesets only
   // runs the ROOT `version` script — but every path it touches is inside the EQL
@@ -62,6 +173,21 @@ function main() {
     bumpCargoPackageVersion(readFileSync(cargoPath, 'utf8'), version),
   )
 
+  // Before the SQL build, not after: this is cheap and offline, so a cargo that
+  // cannot run should stop the release in seconds rather than after a full
+  // eql-codegen compile.
+  const workspaces = cargoLockWorkspaces(stackRoot)
+  if (workspaces.length === 0) {
+    throw new Error(
+      `no Cargo.lock under ${stackRoot} records \`${LOCKED_CRATE}\` as a path dependency — ` +
+        'the scan that finds the locks to refresh has stopped matching, so the bump above ' +
+        'would leave every one of them stale.',
+    )
+  }
+  for (const workspace of workspaces) {
+    refreshCargoLock({ root: stackRoot, eqlRoot, workspace })
+  }
+
   // Build the exact-version SQL and copy it (+ manifests) into both packages.
   execFileSync(
     'mise',
@@ -73,7 +199,8 @@ function main() {
   )
 
   console.log(
-    `synced EQL lockstep version ${version} to Cargo.toml + bundled SQL assets`,
+    `synced EQL lockstep version ${version} to Cargo.toml, ` +
+      `${workspaces.length} Cargo.lock (${workspaces.join(', ')}) + bundled SQL assets`,
   )
 }
 

From ca2b0a758d0331cf13e5dd39d9be068046f9294e Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:26:07 +1000
Subject: [PATCH 10/20] ci(eql): hash the new compile input, and give the PG
 matrix a trigger that fires
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

THE CACHE KEYS COULD NOT SEE THE PATH DEP. Phase 3 pointed protect-ffi at
`eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, making it a
compile input to index.node and to the wasm build — but both keys in
build-ffi-binding hashed only `packages/protect-ffi/**`. A src-only edit
there changes no hashed file (path deps carry no lock checksum), so the
cache hits, the cargo step is skipped, and every credentialed job runs a
stale binding. This contradicts the action's own stated invariant, and this
PR demonstrated it: the 3.0.4 -> 4.0.0 -> 3.0.5 bumps moved neither key.

Scoped to `packages/eql/crates/**` rather than the bindings crate alone.
That crate has no path deps of its own TODAY, so the narrow glob would be
exact — and would silently stop being exact the moment it gains one, which
is the same hole one level down. `packages/eql/Cargo.toml` is in because
three of its four siblings inherit `[lints] workspace = true`, so the
workspace root is one key away from being a compile input with no other
trace. The discovery test follows path deps transitively and asserts every
git-tracked file under each is covered, so a future dep is caught the day
it lands rather than the day it breaks.

THE PG 14-16 MATRIX RAN NEVER. test-eql.yml gated the full matrix behind
`merge_group` alone and dropped `push:` on the justification that "under a
required merge queue, push-to-main validation is redundant". Every clause
of that is false here, checked against the live API: `mergeQueue(branch:
"main")` is null, `branches/main/protection` 404s, and the active ruleset
carries no `required_status_checks` rule — so `ci-required` is required by
nothing and `merge_group` is an event this repo never emits. Both failures
are invisible, because an event that is never delivered produces no runs to
notice the absence of.

`setup` is now an EXCLUSION — the full matrix is the default and the PR
fast lane is the special case — so a trigger added later gets more coverage
rather than silently none. Every gated job's `if:` was inverted to match.
`push` carries a paths filter (nothing waits on a push run, so a skip costs
nothing) and `schedule` backstops what the filter cannot see; the expensive
axis is the fan-out, not the trigger.

The fail-fast audit found SEVEN multi-command `run:` blocks across three
workflows lacking `set -e` under `shell: bash {0}`, not the one reported.
The worst is macro-expand-eql's `mise run test:matrix:expand` followed by
`git diff --exit-code` on the files it regenerates: when the regeneration
breaks, the snapshots are untouched, the diff is clean, and the job goes
green having verified that a build which never ran produced no drift.

integration-drizzle and integration-protect-ffi gained the EQL crate paths
because adding them to the WASM cache key makes them WASM build inputs, and
wasm-build-inputs-paths-filter.test.mjs enforces that relationship — both
run build-ffi-binding with `wasm: 'true'` and load protect_ffi_inline.js.
---
 .github/actions/build-ffi-binding/action.yml  |  39 +-
 .github/workflows/bench-eql.yml               |  48 ++-
 .github/workflows/integration-drizzle.yml     |  20 +
 .github/workflows/integration-protect-ffi.yml |  20 +
 .github/workflows/macro-expand-eql.yml        |  18 +
 .github/workflows/test-eql.yml                | 254 +++++++++----
 .../__tests__/eql-matrix-triggers.test.mjs    | 353 ++++++++++++++++++
 .../__tests__/eql-workflow-filters.test.mjs   | 232 ++++++++++++
 scripts/__tests__/ffi-binding-action.test.mjs | 255 ++++++++++++-
 .../workflow-dispatch-job-conditions.test.mjs |   5 +-
 .../workflow-paths-filter-parity.test.mjs     |  18 +
 .../__tests__/workflow-run-fail-fast.test.mjs | 263 +++++++++++++
 12 files changed, 1445 insertions(+), 80 deletions(-)
 create mode 100644 scripts/__tests__/eql-matrix-triggers.test.mjs
 create mode 100644 scripts/__tests__/eql-workflow-filters.test.mjs
 create mode 100644 scripts/__tests__/workflow-run-fail-fast.test.mjs

diff --git a/.github/actions/build-ffi-binding/action.yml b/.github/actions/build-ffi-binding/action.yml
index ea5bc72e8..bee2c7228 100644
--- a/.github/actions/build-ffi-binding/action.yml
+++ b/.github/actions/build-ffi-binding/action.yml
@@ -54,13 +54,41 @@ runs:
         # package.json, and mise.toml pins the toolchain that compiles it.
         # Edit either and the Rust hash is unchanged, so the cache hit skips
         # the build step below and the job proceeds on a stale index.node.
+        #
+        # The last two are NOT in this package. `crates/protect-ffi/Cargo.toml`
+        # carries `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`
+        # — an in-tree path dependency that compiles into `index.node` and into
+        # the wasm build below. A path dep has no registry checksum, so a
+        # source-only edit there moves NOTHING this key would otherwise hash:
+        # not `crates/**`, not either manifest, and not `Cargo.lock`, which
+        # records the crate by name and version and only moves when the version
+        # does. Every glob hashes identically, the restore hits, the build below
+        # is skipped, and every credentialed job runs a stale binding. (This is
+        # observed, not theoretical: the crate went 3.0.4 -> 4.0.0 -> 3.0.5
+        # across three commits and neither key here changed by a byte.)
+        #
+        # `crates/**` rather than the one crate, deliberately. `eql-bindings`
+        # has no path deps of its own TODAY, so the narrower glob would be exact
+        # — and would silently stop being exact the moment it gains one on a
+        # sibling in that workspace, which is the same hole one level down. The
+        # cost of the wider glob is a spurious miss when an unrelated EQL crate
+        # changes; the cost of the narrower one is a stale binary. Guarded by
+        # `scripts/__tests__/ffi-binding-action.test.mjs`, which discovers the
+        # path deps from the manifest rather than trusting this comment.
+        #
+        # The EQL workspace root manifest comes with it: cargo reads it for the
+        # crate's workspace context, so a `<key>.workspace = true` added to
+        # eql-bindings (three of its four siblings already inherit `[lints]`
+        # that way) would make it a compile input with no other trace.
         key: >-
           ffi-native-${{ runner.os }}-${{ runner.arch }}-${{
           hashFiles('packages/protect-ffi/crates/**',
           'packages/protect-ffi/Cargo.toml',
           'packages/protect-ffi/Cargo.lock',
           'packages/protect-ffi/package.json',
-          'packages/protect-ffi/mise.toml') }}
+          'packages/protect-ffi/mise.toml',
+          'packages/eql/crates/**',
+          'packages/eql/Cargo.toml') }}
 
     # Always, hit or miss: `lib/` is `tsc` over `src/`, which is seconds, and
     # it tracks a different input set than the cached binary.
@@ -136,11 +164,20 @@ runs:
         # under src/ are the eql-v3-types declarations, which that tsconfig
         # never reads. ffi-binding-action.test.mjs walks the tsconfig's imports
         # and fails if this stops being the complete input set.
+        #
+        # `packages/eql/**` is here for the reason spelled out on the native key
+        # above, and it is NOT redundant with it: wasm-pack compiles the same
+        # `eql-bindings` path dependency for wasm32 into
+        # `protect_ffi_inline.js`, which is the bundle
+        # `@cipherstash/stack/wasm-inline` imports. Two keys, two archives, the
+        # same missing input.
         key: >-
           ffi-wasm-${{ runner.os }}-${{
           hashFiles('packages/protect-ffi/crates/**',
           'packages/protect-ffi/Cargo.toml',
           'packages/protect-ffi/Cargo.lock',
+          'packages/eql/crates/**',
+          'packages/eql/Cargo.toml',
           'packages/protect-ffi/dist/wasm/*.d.ts',
           'packages/protect-ffi/src/errors.ts',
           'packages/protect-ffi/package.json',
diff --git a/.github/workflows/bench-eql.yml b/.github/workflows/bench-eql.yml
index b49787ffa..eb9a1952b 100644
--- a/.github/workflows/bench-eql.yml
+++ b/.github/workflows/bench-eql.yml
@@ -17,17 +17,39 @@ on:
     branches:
       - main
     # Repo-root relative, so every entry gained the subtree prefix. Unprefixed,
-    # `src/**/*.sql` and `tests/sqlx/**/*` match nothing under this repository's
-    # root and the bench would simply stop running on pushes — silently, since
-    # a workflow that never triggers reports nothing at all.
+    # `src/**` and `tests/**` match nothing under this repository's root and the
+    # bench would simply stop running on pushes — silently, since a workflow
+    # that never triggers reports nothing at all.
+    #
+    # IDENTICAL to `test-eql.yml`'s list, modulo each file naming itself, and
+    # held that way by `scripts/__tests__/eql-workflow-filters.test.mjs`. The
+    # bench is a strict subset of that suite's inputs, so a bespoke narrower
+    # list here is possible and was what the port carried — and it had drifted
+    # three ways, each of them a change that alters what the bench measures
+    # while never starting it:
+    #
+    #   * `src/**/*.sql` missed `src/v3/version.template`, which `tasks/build.sh`
+    #     names in its own `#MISE sources` and `sed`s into `version.sql`.
+    #   * `tests/sqlx/**/*` missed `tests/docker-compose.yml` — the file
+    #     `postgres:up` actually runs, one level above the glob.
+    #   * `mise.toml` was absent entirely, and it defines every `mise run` task
+    #     below plus the toolchain that compiles them.
+    #
+    # Two lists that answer the same question are worth more kept equal than
+    # kept minimal: the cost of over-triggering is one nightly-budget bench run,
+    # and the cost of under-triggering is a regression that lands and is
+    # attributed to whatever merges next.
     paths:
       - ".github/workflows/bench-eql.yml"
-      - "packages/eql/src/**/*.sql"
-      - "packages/eql/tests/sqlx/**/*"
-      - "packages/eql/tasks/**/*"
+      - ".github/actions/require-cs-secrets/**"
+      - "packages/eql/src/**"
+      - "packages/eql/tests/**"
+      - "packages/eql/tasks/**"
       - "packages/eql/crates/**"
+      - "packages/eql/packages/**"
       - "packages/eql/Cargo.toml"
       - "packages/eql/Cargo.lock"
+      - "packages/eql/mise.toml"
 
   schedule:
     # 02:00 UTC daily
@@ -113,7 +135,17 @@ jobs:
           CS_WORKSPACE_CRN: ${{ vars.CS_WORKSPACE_CRN }}
           CS_CLIENT_ID: ${{ vars.CS_CLIENT_ID }}
           CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }}
+        # `set -euo pipefail` because the workflow-wide `shell: bash {0}` drops
+        # GitHub's implicit `-eo pipefail`: without it a failing `rustup
+        # component add` is discarded and only `test:bench` decides the step,
+        # which then fails several minutes later for a reason that reads as a
+        # bench regression. Enforced by
+        # `scripts/__tests__/workflow-run-fail-fast.test.mjs`.
+        #
+        # Assignment on its own rather than `export x=$(…)`: errexit ignores
+        # the substitution's status when the line starts with a command word.
         run: |
-          export active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1)
-          rustup component add --toolchain ${active_rust_toolchain} rustfmt clippy
+          set -euo pipefail
+          active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1)
+          rustup component add --toolchain "${active_rust_toolchain}" rustfmt clippy
           mise run --output prefix test:bench --postgres ${POSTGRES_VERSION}
diff --git a/.github/workflows/integration-drizzle.yml b/.github/workflows/integration-drizzle.yml
index 107b2b7bd..cc4658036 100644
--- a/.github/workflows/integration-drizzle.yml
+++ b/.github/workflows/integration-drizzle.yml
@@ -86,6 +86,16 @@ on:
       # Pinned by scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs.
       - 'packages/protect-ffi/tsconfig.wasm-errors.json'
       - 'packages/protect-ffi/scripts/inline-wasm.mjs'
+      # Out of that package, and compiled into the same two artifacts: the
+      # cdylib crate carries
+      # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the
+      # EQL wire types are linked into `index.node` and into
+      # `protect_ffi_inline.js`. Both cache keys in
+      # `.github/actions/build-ffi-binding` hash them, so an edit here misses
+      # that cache and rebuilds the bundle the `integration/wasm/**` suites
+      # load. Same argument as the two entries above, same guard.
+      - 'packages/eql/crates/**'
+      - 'packages/eql/Cargo.toml'
   pull_request:
     branches: ['**']
     # Repeated verbatim: GitHub Actions does not support YAML anchors/aliases.
@@ -160,6 +170,16 @@ on:
       # Pinned by scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs.
       - 'packages/protect-ffi/tsconfig.wasm-errors.json'
       - 'packages/protect-ffi/scripts/inline-wasm.mjs'
+      # Out of that package, and compiled into the same two artifacts: the
+      # cdylib crate carries
+      # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the
+      # EQL wire types are linked into `index.node` and into
+      # `protect_ffi_inline.js`. Both cache keys in
+      # `.github/actions/build-ffi-binding` hash them, so an edit here misses
+      # that cache and rebuilds the bundle the `integration/wasm/**` suites
+      # load. Same argument as the two entries above, same guard.
+      - 'packages/eql/crates/**'
+      - 'packages/eql/Cargo.toml'
 
 jobs:
   integration:
diff --git a/.github/workflows/integration-protect-ffi.yml b/.github/workflows/integration-protect-ffi.yml
index fcd48f90b..f95d4c743 100644
--- a/.github/workflows/integration-protect-ffi.yml
+++ b/.github/workflows/integration-protect-ffi.yml
@@ -61,6 +61,16 @@ on:
       # toolchain pins, and the PG* connection env.
       - 'packages/protect-ffi/package.json'
       - 'packages/protect-ffi/mise.toml'
+      # Out of this package, and a real compile input: the cdylib crate carries
+      # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the
+      # EQL wire types are linked into `index.node` AND into the wasm32 build
+      # this suite's `wasm-round-trip` test loads. Both cache keys in
+      # `.github/actions/build-ffi-binding` hash these, so an edit misses the
+      # cache and rebuilds the binding — without these entries it would be
+      # rebuilt and no suite that loads it would start. Pinned by
+      # scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs.
+      - 'packages/eql/crates/**'
+      - 'packages/eql/Cargo.toml'
       - '.github/workflows/integration-protect-ffi.yml'
       - '.github/actions/build-ffi-binding/**'
       - '.github/actions/require-cs-secrets/**'
@@ -79,6 +89,16 @@ on:
       - 'packages/protect-ffi/tsconfig.wasm-errors.json'
       - 'packages/protect-ffi/package.json'
       - 'packages/protect-ffi/mise.toml'
+      # Out of this package, and a real compile input: the cdylib crate carries
+      # `eql-bindings = { path = "../../../eql/crates/eql-bindings" }`, so the
+      # EQL wire types are linked into `index.node` AND into the wasm32 build
+      # this suite's `wasm-round-trip` test loads. Both cache keys in
+      # `.github/actions/build-ffi-binding` hash these, so an edit misses the
+      # cache and rebuilds the binding — without these entries it would be
+      # rebuilt and no suite that loads it would start. Pinned by
+      # scripts/__tests__/wasm-build-inputs-paths-filter.test.mjs.
+      - 'packages/eql/crates/**'
+      - 'packages/eql/Cargo.toml'
       - '.github/workflows/integration-protect-ffi.yml'
       - '.github/actions/build-ffi-binding/**'
       - '.github/actions/require-cs-secrets/**'
diff --git a/.github/workflows/macro-expand-eql.yml b/.github/workflows/macro-expand-eql.yml
index 5496b5620..76ee3391d 100644
--- a/.github/workflows/macro-expand-eql.yml
+++ b/.github/workflows/macro-expand-eql.yml
@@ -80,13 +80,31 @@ jobs:
       # an unpinned version could drift the snapshot even with a frozen macro +
       # nightly. The snapshot then only moves when the macro moves.
       - name: Install pinned nightly toolchain
+        # `set -eu`, deliberately WITHOUT `pipefail`: the workflow-wide
+        # `shell: bash {0}` drops GitHub's implicit `-eo pipefail`, so errexit
+        # has to be asked for (see
+        # `scripts/__tests__/workflow-run-fail-fast.test.mjs`) — but `head -1`
+        # closes the pipe as soon as it has its line, so under `pipefail` a
+        # grep that still had output to write reports 141 and fails the step on
+        # a successful match. Same SIGPIPE hazard as
+        # `scripts/__tests__/workflow-grep-q-pipelines.test.mjs`. The `test -n`
+        # below already covers the case this pipeline can genuinely fail in.
         run: |
+          set -eu
           NIGHTLY=$(grep -oE 'nightly-[0-9]{4}-[0-9]{2}-[0-9]{2}' mise.toml | head -1)
           test -n "$NIGHTLY" || { echo "could not find pinned nightly in mise.toml"; exit 1; }
           rustup toolchain install "$NIGHTLY" --profile minimal --component rustfmt
 
       - name: Regenerate and verify the matrix expansion snapshots
+        # `set -euo pipefail` is load-bearing here, more than anywhere else in
+        # this file. Without it the workflow-wide `shell: bash {0}` discards the
+        # regeneration's exit code and the `git diff` below decides the step —
+        # so when `test:matrix:expand` BREAKS, the snapshots are untouched, the
+        # diff is clean, and this job reports success having verified that a
+        # build which never ran produced no drift. Enforced by
+        # `scripts/__tests__/workflow-run-fail-fast.test.mjs`.
         run: |
+          set -euo pipefail
           mise run test:matrix:expand
           git diff --exit-code -- \
             tests/sqlx/snapshots/integer_expanded.rs \
diff --git a/.github/workflows/test-eql.yml b/.github/workflows/test-eql.yml
index b6cdf71db..cf52c8de5 100644
--- a/.github/workflows/test-eql.yml
+++ b/.github/workflows/test-eql.yml
@@ -30,19 +30,63 @@ name: "Test EQL"
 # — it yields the empty string, and the suite would fail at client construction
 # in every shard instead of saying what was missing.
 #
-# NB: NO path filter at on: level. A workflow skipped by a path/branch filter
+# NB: NO path filter on `pull_request`. A workflow skipped by a path filter
 # leaves its required checks stuck Pending and blocks merge. Relevance is
-# computed by the `changes` job and applied per-job via `if:` instead.
+# computed by the `changes` job and applied per-job via `if:` instead. `push`
+# carries one because nothing waits on a push run, so a skipped one costs
+# nothing — and the two lists are kept identical by
+# `scripts/__tests__/eql-workflow-filters.test.mjs`.
 #
-# NB: NO `push:` trigger, and that is not the same as "runs rarely". This runs
-# on `pull_request` — every PR, unfiltered, with relevance applied per job — and
-# on `merge_group`. Under a required merge queue, push-to-main validation is
-# redundant: the queue already validated the exact merge commit, and branch
-# protection blocks direct pushes. (Resolves the design's ambiguous "light jobs
-# only on push:main" sanity net by dropping the trigger entirely.)
+# WHY `push` AND `schedule` EXIST. The port arrived with `merge_group` as the
+# ONLY route to the full PG 14-17 matrix, and with no `push:` at all,
+# justified by "under a required merge queue, push-to-main validation is
+# redundant". Every clause of that premise is false in this repository, checked
+# against the live API: there is no merge queue on `main`
+# (`mergeQueue(branch:"main")` -> null), `main` is not protected
+# (`branches/main/protection` -> 404), and the active ruleset carries no
+# `required_status_checks` rule, so `ci-required` is required by nothing.
+# `merge_group` is an event this repo never emits — so PG 14, 15 and 16 were
+# tested NEVER, and nothing EQL-related ran after a merge. Both failures are
+# invisible, because an event that is never delivered produces no runs to
+# notice the absence of. Pinned by
+# `scripts/__tests__/eql-matrix-triggers.test.mjs`, which refuses to count
+# `merge_group` or `workflow_dispatch` as reachable.
+#
+# WHY THIS SHAPE, and not "full matrix on every push". The expensive axis is
+# the fan-out, not the trigger: PG 14-17 x 2 shards is roughly double the
+# runner-minutes of the PR lane. So the cost is bounded by the FILTER rather
+# than by running a smaller matrix — a `push` run only starts when the merge
+# actually touched EQL, which is a small fraction of merges to `main`, and when
+# it does start the extra PG versions are the entire reason to run it at all.
+# Attributing a PG14 break to the merge that caused it is worth much more than
+# finding it detached at 04:00 the next morning. `schedule` then backstops the
+# case the filter cannot see (a dependency or toolchain moving underneath a
+# tree nobody touched), and both use the same full matrix.
+#
+# `pull_request` keeps the fast lane — PG17 x 4 shards, every PR, unfiltered,
+# with relevance applied per job — because latency is what matters there and
+# PG17 catches all but version-specific breakage.
 on:
   pull_request: {}
-  merge_group: {}            # required pre-merge gate; runs the full matrix
+  push:
+    branches: [main]
+    # Identical to the `relevant:` filter in the `changes` job below. GitHub
+    # Actions has no YAML anchors, so the list is written twice; the guard named
+    # above fails a one-sided edit.
+    paths:
+      - ".github/workflows/test-eql.yml"
+      - ".github/actions/require-cs-secrets/**"
+      - "packages/eql/src/**"
+      - "packages/eql/tests/**"
+      - "packages/eql/tasks/**"
+      - "packages/eql/crates/**"
+      - "packages/eql/packages/**"
+      - "packages/eql/Cargo.toml"
+      - "packages/eql/Cargo.lock"
+      - "packages/eql/mise.toml"
+  schedule:
+    - cron: "0 4 * * *"      # 04:00 UTC daily; full matrix, off the merge path
+  merge_group: {}            # inert today (no queue); kept so enabling one works
   workflow_dispatch: {}      # manual runs use the PR shape (PG17 x 4 shards)
 
 env:
@@ -88,7 +132,10 @@ jobs:
           persist-credentials: false
 
       # Diff ONLY on pull_request, where a base ref is well-defined. On
-      # merge_group/workflow_dispatch the base ref is absent and the filter errors/empties.
+      # push/schedule/merge_group/workflow_dispatch there is no base ref to
+      # diff against and the filter errors or empties — so those events take the
+      # hardcoded default in the step below instead. `push` does not need it:
+      # its `on:`-level `paths:` has already decided whether the run happens.
       - id: f
         if: github.event_name == 'pull_request'
         uses: dorny/paths-filter@d1c1ffe0248fe513906c8e24db8ea791d46f8590 # v3
@@ -99,32 +146,53 @@ jobs:
           # `packages/stack/src/**` and friends instead — firing the whole
           # matrix on changes that cannot affect EQL, and (worse) NOT firing on
           # EQL's own `src/`, since nothing at the repo root is called that.
+          #
+          # Identical to the `push` `paths:` list at the top of this file — the
+          # same question asked of two mechanisms GitHub gives no way to share.
+          # `scripts/__tests__/eql-workflow-filters.test.mjs` compares them, and
+          # also fails any entry here that matches no tracked file (a dead
+          # `packages/eql/sql/**` sat in this list from the port: there is no
+          # such directory, so it narrowed the filter by exactly nothing while
+          # reading as coverage).
           filters: |
             relevant:
               - ".github/workflows/test-eql.yml"
+              - ".github/actions/require-cs-secrets/**"
               - "packages/eql/src/**"
-              - "packages/eql/sql/**"
               - "packages/eql/tests/**"
               - "packages/eql/tasks/**"
               - "packages/eql/crates/**"
+              - "packages/eql/packages/**"
               - "packages/eql/Cargo.toml"
               - "packages/eql/Cargo.lock"
               - "packages/eql/mise.toml"
 
       # Explicit default (not `|| 'true'`, which trips GitHub's inconsistent
-      # treatment of the string 'false'). merge_group/workflow_dispatch never
-      # read this value — their downstream `if:` branch ignores `relevant` — but
-      # default true is the safe value regardless.
+      # treatment of the string 'false'). push/schedule/merge_group/dispatch
+      # never run the filter above — it needs a base ref that only a pull
+      # request has — so they take the default, and `push` is already narrowed
+      # by its own `on:`-level `paths:`.
+      #
+      # The event arrives through `env:`, not through a `${{ }}` interpolated
+      # into the body. That is what lets
+      # `scripts/__tests__/eql-matrix-triggers.test.mjs` EXECUTE this script
+      # once per event and read back what it wrote, rather than reimplementing
+      # the branch and agreeing with a rewritten one by luck.
       - id: r
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          FILTER_RELEVANT: ${{ steps.f.outputs.relevant }}
         run: |
-          if [ "${{ github.event_name }}" = "pull_request" ]; then
-            echo "relevant=${{ steps.f.outputs.relevant }}" >> "$GITHUB_OUTPUT"
+          set -euo pipefail
+          if [ "$EVENT_NAME" = "pull_request" ]; then
+            echo "relevant=$FILTER_RELEVANT" >> "$GITHUB_OUTPUT"
           else
             echo "relevant=true" >> "$GITHUB_OUTPUT"
           fi
 
   # Pure bash; no checkout/toolchain. Derives the PG-version + shard fan-out
-  # from the event: PR -> PG17 x 4 shards; merge queue -> PG 14-17 x 2 shards.
+  # from the event: PR and manual dispatch -> PG17 x 4 shards (latency lane);
+  # everything else -> PG 14-17 x 2 shards (coverage lane).
   setup:
     name: "Compute matrix"
     runs-on: blacksmith-16vcpu-ubuntu-2204
@@ -141,33 +209,61 @@ jobs:
       shard-total: ${{ steps.cfg.outputs.shard_total }}
       shards: ${{ steps.cfg.outputs.shards }}
     steps:
+      # Written as an exclusion, and that direction is the point: the FULL
+      # matrix is the default, so a trigger added later lands in the coverage
+      # lane rather than in the fast one. The version of this that enumerated
+      # `merge_group` as the only full-matrix event is why PG 14-16 went
+      # untested for the life of the port — an allowlist fails shut on the case
+      # nobody enumerated, and here "shut" meant three Postgres versions.
+      #
+      # The event arrives through `env:` rather than an interpolated `${{ }}`
+      # so `scripts/__tests__/eql-matrix-triggers.test.mjs` can run this script
+      # against each event and read the real fan-out back out of
+      # `$GITHUB_OUTPUT`.
       - id: cfg
+        env:
+          EVENT_NAME: ${{ github.event_name }}
         run: |
-          if [ "${{ github.event_name }}" = "merge_group" ]; then
-            echo 'pg=[14,15,16,17]' >> "$GITHUB_OUTPUT"
-            echo 'shard_total=2'    >> "$GITHUB_OUTPUT"
-            echo 'shards=[1,2]'     >> "$GITHUB_OUTPUT"
-          else
-            echo 'pg=[17]'          >> "$GITHUB_OUTPUT"
-            echo 'shard_total=4'    >> "$GITHUB_OUTPUT"
-            echo 'shards=[1,2,3,4]' >> "$GITHUB_OUTPUT"
-          fi
-
-  # Compile the test binaries ONCE. Runs in the queue and on workflow_dispatch
-  # always, and on PRs only when relevant files changed (docs-only PRs never pay
-  # the ~4-min compile).
+          set -euo pipefail
+          case "$EVENT_NAME" in
+            pull_request|workflow_dispatch)
+              # Latency lane: PG17 only, split four ways.
+              echo 'pg=[17]'          >> "$GITHUB_OUTPUT"
+              echo 'shard_total=4'    >> "$GITHUB_OUTPUT"
+              echo 'shards=[1,2,3,4]' >> "$GITHUB_OUTPUT"
+              ;;
+            *)
+              # Coverage lane: every version tests/docker-compose.yml ships a
+              # container for. Kept in step by the guard named above.
+              echo 'pg=[14,15,16,17]' >> "$GITHUB_OUTPUT"
+              echo 'shard_total=2'    >> "$GITHUB_OUTPUT"
+              echo 'shards=[1,2]'     >> "$GITHUB_OUTPUT"
+              ;;
+          esac
+
+  # Compile the test binaries ONCE. Runs on every non-PR event, and on PRs only
+  # when relevant files changed (docs-only PRs never pay the ~4-min compile).
   build-archive:
     name: "Build test archive"
     needs: [changes]
     # This repo is PUBLIC and accepts fork PRs (the approval policy only gates
     # first-time contributors). build-archive is the sole holder of the CS_*
     # credentials below, so it must never run on a fork PR. The trailing clause
-    # restricts it to push / workflow_dispatch / same-repo branch PRs; the
-    # downstream test/validate shards `needs:` it, so they skip on fork PRs too.
+    # is the only thing that skips it: a fork pull request. Every other event —
+    # push, schedule, merge_group, dispatch, and a same-repo branch PR — runs;
+    # the downstream test/validate shards `needs:` it, so they skip on fork PRs
+    # too.
+    #
+    # Both clauses are written as exclusions rather than as a list of admitted
+    # events. An allowlist fails SHUT on the event nobody enumerated, and the
+    # `push`/`schedule` triggers added above would have skipped every job in
+    # this file while the run still reported success. Pinned by
+    # `scripts/__tests__/eql-matrix-triggers.test.mjs`; the fork clause itself
+    # is compared verbatim across all eight copies in the repo by
+    # `scripts/__tests__/workflow-dispatch-job-conditions.test.mjs`.
     if: >-
-      (github.event_name == 'merge_group'
-       || github.event_name == 'workflow_dispatch'
-       || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true'))
+      (github.event_name != 'pull_request'
+       || needs.changes.outputs.relevant == 'true')
       && (github.event_name != 'pull_request'
           || github.event.pull_request.head.repo.full_name == github.repository)
     runs-on: blacksmith-16vcpu-ubuntu-2204
@@ -248,10 +344,10 @@ jobs:
   test:
     name: "Shard PG${{ matrix.postgres-version }} ${{ matrix.shard }}/${{ needs.setup.outputs.shard-total }}"
     needs: [changes, setup, build-archive]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     strategy:
       fail-fast: false
@@ -308,10 +404,10 @@ jobs:
   validate:
     name: "Validate (Postgres ${{ matrix.postgres-version }})"
     needs: [changes, setup]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     strategy:
       fail-fast: false
@@ -350,17 +446,25 @@ jobs:
           mise run docs:validate:documented-sql
 
       - name: Clean-DB v3 install smoke (Postgres ${{ matrix.postgres-version }})
+        # `set -euo pipefail` for the reason spelled out on `matrix-coverage`'s
+        # inventory step and enforced by
+        # `scripts/__tests__/workflow-run-fail-fast.test.mjs`: the workflow-wide
+        # `shell: bash {0}` drops GitHub's implicit `-eo pipefail`, so without
+        # it a failing BUILD on the first line is discarded and the smoke test
+        # on the second decides the step — i.e. the install smoke would pass by
+        # installing the previous build.
         run: |
+          set -euo pipefail
           mise run clean && mise run build
           mise run test:clean_install_v3
 
   schema:
     name: "JSON Schema validation"
     needs: [changes]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
@@ -384,10 +488,10 @@ jobs:
   rust-crates:
     name: "Rust workspace crates"
     needs: [changes]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
@@ -409,8 +513,13 @@ jobs:
       # standalone `test:lint` step that the removed per-version test job ran.
       - name: Compile, lint and test the Rust workspace crates
         run: |
-          export active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1)
-          rustup component add --toolchain ${active_rust_toolchain} rustfmt clippy
+          set -euo pipefail
+          # Assignment on its own, not `export x=$(…)`: errexit ignores the
+          # substitution's status when the line starts with a command word, so
+          # the `export` form would swallow a failing `rustup show` even under
+          # `set -e`.
+          active_rust_toolchain=$(rustup show active-toolchain | cut -d' ' -f1)
+          rustup component add --toolchain "${active_rust_toolchain}" rustfmt clippy
           mise run test:crates
 
       # Freshness gate for the eql-types codegen output: regenerate the
@@ -433,10 +542,10 @@ jobs:
   codegen:
     name: "Encrypted-domain codegen"
     needs: [changes]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
@@ -463,10 +572,10 @@ jobs:
   self-contained-v3:
     name: "eql_v3 self-containment"
     needs: [changes]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
@@ -497,10 +606,10 @@ jobs:
   matrix-coverage:
     name: "Matrix coverage inventory"
     needs: [changes]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     steps:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
@@ -537,10 +646,10 @@ jobs:
   splinter:
     name: "Supabase splinter"
     needs: [changes]
+    # Exclusion, not an allowlist — see the note on `build-archive`.
     if: >-
-      github.event_name == 'merge_group'
-      || github.event_name == 'workflow_dispatch'
-      || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true')
+      github.event_name != 'pull_request'
+      || needs.changes.outputs.relevant == 'true'
     runs-on: blacksmith-16vcpu-ubuntu-2204
     env:
       POSTGRES_VERSION: "17"
@@ -559,11 +668,18 @@ jobs:
           mise run postgres:up postgres-${POSTGRES_VERSION} --extra-args "--detach --wait"
       - name: Build and install EQL
         run: |
+          set -euo pipefail
           mise run clean && mise run --output prefix --force build
-          cat release/cipherstash-encrypt.sql \
-            | docker exec -i postgres-${POSTGRES_VERSION} \
-                psql -v ON_ERROR_STOP=1 \
-                  postgresql://cipherstash:password@localhost/cipherstash -f-
+          # Redirected, not piped. `psql -v ON_ERROR_STOP=1` exits at the first
+          # SQL error, which under `pipefail` leaves a `cat` writing into a
+          # closed pipe and reports the step as 141 — the SIGPIPE hazard
+          # `scripts/__tests__/workflow-grep-q-pipelines.test.mjs` documents.
+          # The redirect is the same bytes with no writer to signal, so the
+          # step reports psql's own status and says which statement failed.
+          docker exec -i postgres-${POSTGRES_VERSION} \
+            psql -v ON_ERROR_STOP=1 \
+              postgresql://cipherstash:password@localhost/cipherstash -f- \
+            < release/cipherstash-encrypt.sql
       - name: Run splinter
         run: |
           mise run --output prefix test:splinter --postgres ${POSTGRES_VERSION}
@@ -672,10 +788,11 @@ jobs:
   e2e:
     name: "e2e property suite (fresh encryption)"
     needs: [changes, setup]
+    # Exclusion, not an allowlist — see the note on `build-archive`, which
+    # carries the same two clauses for the same two reasons.
     if: >-
-      (github.event_name == 'merge_group'
-       || github.event_name == 'workflow_dispatch'
-       || (github.event_name == 'pull_request' && needs.changes.outputs.relevant == 'true'))
+      (github.event_name != 'pull_request'
+       || needs.changes.outputs.relevant == 'true')
       && (github.event_name != 'pull_request'
           || github.event.pull_request.head.repo.full_name == github.repository)
     runs-on: blacksmith-16vcpu-ubuntu-2204
@@ -739,6 +856,7 @@ jobs:
     steps:
       - name: Assert all required jobs passed or were skipped
         run: |
+          set -euo pipefail
           results='${{ join(needs.*.result, ' ') }}'
           echo "needed results: $results"
           for r in $results; do
diff --git a/scripts/__tests__/eql-matrix-triggers.test.mjs b/scripts/__tests__/eql-matrix-triggers.test.mjs
new file mode 100644
index 000000000..1f0fe9f60
--- /dev/null
+++ b/scripts/__tests__/eql-matrix-triggers.test.mjs
@@ -0,0 +1,353 @@
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import yaml from 'js-yaml'
+import { afterAll, describe, expect, it } from 'vitest'
+import { REPO_ROOT } from './lib/repo-root.mjs'
+import { readWorkflow } from './lib/workflows.mjs'
+
+/**
+ * The EQL suite's full Postgres matrix must be reachable by a trigger that
+ * actually fires in THIS repository.
+ *
+ * WHAT HAPPENED. The workflow arrived from `cipherstash/encrypt-query-language`
+ * with the subtree, and its `setup` job derives the fan-out from the event:
+ * `merge_group` gets PG 14-17, everything else gets PG17 alone. The port also
+ * dropped the `push:` trigger, justified in the file header by "Under a
+ * required merge queue, push-to-main validation is redundant: the queue already
+ * validated the exact merge commit, and branch protection blocks direct
+ * pushes."
+ *
+ * Every clause of that premise is false here. Checked against the live repo:
+ *
+ *   gh api graphql '{repository(owner:"cipherstash",name:"stack"){
+ *     mergeQueue(branch:"main"){id}}}'   ->  {"mergeQueue": null}
+ *   gh api repos/cipherstash/stack/branches/main/protection
+ *                                        ->  404 "Branch not protected"
+ *   the active ruleset (id 4478501) carries only `deletion`, `pull_request`
+ *   (1 approval), `non_fast_forward` and `required_signatures` — there is NO
+ *   `required_status_checks` rule, so `ci-required` is required by nothing.
+ *
+ * `merge_group` is therefore an event this repository never emits. `test-eql.yml`
+ * is the only workflow in the tree that declares it, and it was the sole gate on
+ * the full matrix — so PG 14, 15 and 16 were tested NEVER, and with `push:`
+ * gone nothing EQL-related ran post-merge at all. Both failures are invisible:
+ * an event that is never delivered produces no runs to notice the absence of.
+ *
+ * WHY THE PROPERTY IS SPELLED THIS WAY. A test in the tree cannot query repo
+ * settings, and one that could would be asserting about a mutable dashboard
+ * rather than about this file. So the invariant is encoded structurally: the
+ * full matrix must be reachable from `push`, `schedule` or `pull_request` —
+ * events GitHub delivers on its own. `merge_group` and `workflow_dispatch` are
+ * deliberately excluded: the first requires a merge queue that does not exist,
+ * the second requires a human to press a button, and "someone could run it by
+ * hand" is not coverage. If a merge queue is turned on later, `merge_group` may
+ * be ADDED to the full-matrix path — it may not become the only one again
+ * without deleting this test on purpose.
+ *
+ * The fan-out is not re-derived here, it is EXECUTED: the `setup` job's script
+ * is run once per candidate event and its real `$GITHUB_OUTPUT` is read back.
+ * A guard that reimplemented the if/else would agree with a rewritten script
+ * exactly as often as it disagreed.
+ */
+
+const WORKFLOW = '.github/workflows/test-eql.yml'
+const COMPOSE = 'packages/eql/tests/docker-compose.yml'
+
+/**
+ * The events GitHub delivers without a merge queue and without a human. The
+ * whole point of the file — see the header.
+ */
+const SELF_FIRING_EVENTS = ['push', 'schedule', 'pull_request']
+
+/** Every event the check evaluates the matrix under. */
+const CANDIDATE_EVENTS = [
+  ...SELF_FIRING_EVENTS,
+  'merge_group',
+  'workflow_dispatch',
+]
+
+const wf = readWorkflow(WORKFLOW)
+
+/** `on:` parses as the boolean `true` under YAML 1.1 — the "Norway problem". */
+const TRIGGERS = (() => {
+  const on = wf?.on ?? wf?.[true]
+  return on && typeof on === 'object' ? on : {}
+})()
+
+const DECLARED = CANDIDATE_EVENTS.filter((event) => event in TRIGGERS)
+
+/**
+ * The Postgres versions this suite ships a container for, read from the compose
+ * file the `postgres:up` task drives rather than listed here.
+ *
+ * Derived because the two lists are one claim: a `postgres-18` service that no
+ * matrix ever selects is a version nobody tests, which is the same defect as
+ * the one above wearing different clothes.
+ */
+function supportedPostgresVersions() {
+  const compose = yaml.load(readFileSync(join(REPO_ROOT, COMPOSE), 'utf8'))
+  return Object.keys(compose?.services ?? {})
+    .map((name) => /^postgres-(\d+)$/.exec(name))
+    .filter(Boolean)
+    .map((match) => Number(match[1]))
+    .sort((a, b) => a - b)
+}
+
+const SUPPORTED_PG = supportedPostgresVersions()
+
+// ---------------------------------------------------------------------------
+// Following the workflow's own data flow to the script that computes the matrix
+// ---------------------------------------------------------------------------
+
+/** `${{ needs.<job>.outputs.<name> }}` -> `{ job, output }`, else null. */
+function needsOutputRef(expression) {
+  const match = /needs\.([A-Za-z0-9_-]+)\.outputs\.([A-Za-z0-9_-]+)/.exec(
+    String(expression ?? ''),
+  )
+  return match ? { job: match[1], output: match[2] } : null
+}
+
+/**
+ * The step that produces `jobs.<job>.outputs.<name>`, found by resolving the
+ * output expression to a step `id`.
+ *
+ * Discovery rather than a named constant: the coupling being checked is
+ * matrix -> job output -> step, and following it means a renamed job or step
+ * fails this file loudly instead of leaving it checking a script nothing runs.
+ */
+function stepProducing({ job, output }) {
+  const definition = wf?.jobs?.[job]
+  const ref = /steps\.([A-Za-z0-9_-]+)\.outputs\./.exec(
+    String(definition?.outputs?.[output] ?? ''),
+  )
+  if (!ref) return null
+  const step = (definition?.steps ?? []).find((entry) => entry?.id === ref[1])
+  return step ? { job, stepId: ref[1], step } : null
+}
+
+/** The job output the matrix's `postgres-version` axis is computed from. */
+const MATRIX_SOURCE = (() => {
+  for (const job of Object.values(wf?.jobs ?? {})) {
+    const axis = job?.strategy?.matrix?.['postgres-version']
+    const ref = needsOutputRef(axis)
+    if (ref) return ref
+  }
+  return null
+})()
+
+/** The relevance flag every gated job's `if:` reads. */
+const RELEVANCE_SOURCE = (() => {
+  for (const job of Object.values(wf?.jobs ?? {})) {
+    const ref = needsOutputRef(job?.if)
+    if (ref) return ref
+  }
+  return null
+})()
+
+const MATRIX_STEP = MATRIX_SOURCE ? stepProducing(MATRIX_SOURCE) : null
+const RELEVANCE_STEP = RELEVANCE_SOURCE ? stepProducing(RELEVANCE_SOURCE) : null
+
+/**
+ * The step `env:` key wired to `${{ github.event_name }}`.
+ *
+ * The script has to read the event from the environment rather than from an
+ * inlined `${{ }}`, precisely so it can be executed here against each event in
+ * turn. That is not a concession to the test: an expression interpolated into a
+ * shell body is unrunnable, unquotable and — for anything less fixed than an
+ * event name — an injection site.
+ */
+function eventEnvKey(step) {
+  return (
+    Object.entries(step?.env ?? {}).find(([, value]) =>
+      /^\$\{\{\s*github\.event_name\s*\}\}$/.test(String(value)),
+    )?.[0] ?? null
+  )
+}
+
+const SCRATCH = mkdtempSync(join(tmpdir(), 'eql-matrix-triggers-'))
+afterAll(() => rmSync(SCRATCH, { recursive: true, force: true }))
+
+let runCounter = 0
+
+/**
+ * Run a step's `run:` body under a synthetic event and return the key/value
+ * pairs it wrote to `$GITHUB_OUTPUT`.
+ *
+ * Every OTHER `env:` entry is set to the empty string, which is what GitHub
+ * actually substitutes for an expression that resolves to nothing — the
+ * relevance step reads `steps.f.outputs.relevant`, and step `f` is skipped on
+ * every event but `pull_request`.
+ */
+function runStep({ step }, eventName) {
+  const envKey = eventEnvKey(step)
+  runCounter += 1
+  const outputFile = join(SCRATCH, `outputs-${runCounter}.txt`)
+  writeEmpty(outputFile)
+
+  const env = { PATH: process.env.PATH, GITHUB_OUTPUT: outputFile }
+  for (const key of Object.keys(step?.env ?? {})) env[key] = ''
+  env[envKey] = eventName
+
+  execFileSync('bash', ['-c', String(step.run)], {
+    cwd: SCRATCH,
+    env,
+    encoding: 'utf8',
+  })
+
+  return Object.fromEntries(
+    readFileSync(outputFile, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        const at = line.indexOf('=')
+        return [line.slice(0, at), line.slice(at + 1)]
+      }),
+  )
+}
+
+function writeEmpty(path) {
+  execFileSync('bash', ['-c', ': > "$1"', 'bash', path])
+}
+
+/** The Postgres versions the matrix fans out to under one event. */
+function pgVersionsFor(eventName) {
+  const outputs = runStep(MATRIX_STEP, eventName)
+  const raw = outputs[MATRIX_SOURCE.output.replace(/-/g, '_')] ?? outputs.pg
+  return JSON.parse(raw)
+    .map(Number)
+    .sort((a, b) => a - b)
+}
+
+const isFullMatrix = (versions) =>
+  SUPPORTED_PG.every((version) => versions.includes(version))
+
+describe('the EQL matrix is reachable by a trigger that fires', () => {
+  it('follows the workflow to the script that computes the fan-out', () => {
+    // Every assertion below runs that script. If the trail from the matrix axis
+    // to it breaks, this file would otherwise report success having executed
+    // nothing — the failure mode the whole directory guards against.
+    expect(
+      MATRIX_SOURCE,
+      `No job in ${WORKFLOW} derives \`strategy.matrix.postgres-version\` from a \`needs.<job>.outputs.<name>\` expression, so there is no fan-out to evaluate.`,
+    ).toBeTruthy()
+    expect(
+      MATRIX_STEP,
+      `\`jobs.${MATRIX_SOURCE?.job}.outputs.${MATRIX_SOURCE?.output}\` does not resolve to a step \`id:\` in that job.`,
+    ).toBeTruthy()
+    expect(
+      eventEnvKey(MATRIX_STEP?.step),
+      `The "${MATRIX_SOURCE?.job}" job's \`${MATRIX_STEP?.stepId}\` step must read the event from its \`env:\` (a key set to \`\${{ github.event_name }}\`) rather than interpolating the expression into the shell body. An inlined expression cannot be executed here, so this guard would silently stop evaluating the real fan-out.`,
+    ).toBeTruthy()
+
+    expect(
+      SUPPORTED_PG.length,
+      `${COMPOSE} declares fewer than two \`postgres-<version>\` services, so "the full matrix" is not a meaningful claim. Either the compose file was restructured or the service naming changed.`,
+    ).toBeGreaterThanOrEqual(2)
+  })
+
+  it('runs the full matrix under at least one event', () => {
+    // Separated from the check below so the two failures read differently: this
+    // one means the workflow no longer HAS a full-matrix path, which is a much
+    // larger finding than it having one behind the wrong trigger.
+    const full = CANDIDATE_EVENTS.filter((event) =>
+      isFullMatrix(pgVersionsFor(event)),
+    )
+    expect(
+      full,
+      `No event makes ${WORKFLOW} fan out across every Postgres version in ${COMPOSE} (${SUPPORTED_PG.join(', ')}). Per event:\n${CANDIDATE_EVENTS.map((event) => `  ${event}: PG ${pgVersionsFor(event).join(', ')}`).join('\n')}`,
+    ).not.toEqual([])
+  })
+
+  it('reaches the full matrix from a trigger this repo actually emits', () => {
+    const reaching = SELF_FIRING_EVENTS.filter(
+      (event) => DECLARED.includes(event) && isFullMatrix(pgVersionsFor(event)),
+    )
+    expect(
+      reaching,
+      `${WORKFLOW} gates its full Postgres matrix behind events this repository never delivers on its own.\nDeclared triggers: ${DECLARED.join(', ') || '(none)'}\nPer event:\n${CANDIDATE_EVENTS.map((event) => `  ${event}: ${DECLARED.includes(event) ? '' : '(not declared) '}PG ${pgVersionsFor(event).join(', ')}`).join('\n')}\nThere is no merge queue on \`main\` and no \`required_status_checks\` rule (see this file's header for the API responses), so \`merge_group\` never fires and \`workflow_dispatch\` needs a human. Give the full matrix a \`push\`, \`schedule\` or \`pull_request\` path.`,
+    ).not.toEqual([])
+  })
+
+  it('keeps a post-merge run of some shape', () => {
+    // Weaker than the check above and not implied by it: a nightly `schedule`
+    // satisfies the full-matrix property while leaving every merge to `main`
+    // unvalidated until 02:00. Both halves were lost in the same edit.
+    expect(
+      DECLARED.filter((event) => event === 'push' || event === 'schedule'),
+      `${WORKFLOW} declares neither \`push\` nor \`schedule\`, so nothing EQL-related runs after a pull request merges. With no branch protection and no merge queue on \`main\`, the pre-merge run is the ONLY run — and it validated the head commit, not the merge result.`,
+    ).not.toEqual([])
+  })
+})
+
+describe('the relevance flag opens on every non-PR event', () => {
+  it('follows the workflow to the step that computes it', () => {
+    expect(
+      RELEVANCE_SOURCE,
+      `No job \`if:\` in ${WORKFLOW} reads a \`needs.<job>.outputs.<name>\` relevance flag, so this suite has nothing to evaluate.`,
+    ).toBeTruthy()
+    expect(RELEVANCE_STEP).toBeTruthy()
+    expect(
+      eventEnvKey(RELEVANCE_STEP?.step),
+      `The "${RELEVANCE_SOURCE?.job}" job's \`${RELEVANCE_STEP?.stepId}\` step must read the event from its \`env:\` rather than inlining \`\${{ github.event_name }}\`, for the reason given on the matrix step.`,
+    ).toBeTruthy()
+  })
+
+  for (const event of CANDIDATE_EVENTS.filter((e) => e !== 'pull_request')) {
+    it(`defaults to relevant on ${event}`, () => {
+      // The path filter only runs on `pull_request` — it needs a base ref — so
+      // on every other event the flag is a hardcoded default. Get that default
+      // wrong and every gated job skips on the new trigger while the run still
+      // reports success, which is the same silent-skip class as the trigger bug
+      // this file exists for.
+      const outputs = runStep(RELEVANCE_STEP, event)
+      expect(
+        outputs[RELEVANCE_SOURCE.output],
+        `The relevance step wrote ${JSON.stringify(outputs)} on a ${event} event. Every heavy job is gated on this being 'true', and the filter that would compute it does not run outside \`pull_request\`.`,
+      ).toBe('true')
+    })
+  }
+})
+
+/**
+ * The structural half, and the one that outlives the specific trigger added
+ * today.
+ *
+ * Every gated job here was written as an ALLOWLIST of events —
+ * `merge_group || workflow_dispatch || (pull_request && relevant)` — which is
+ * the exact defect `workflow-dispatch-job-conditions.test.mjs` was written for
+ * one workflow over: a condition that enumerates the events known at writing
+ * time fails SHUT on the one nobody enumerated. Add a trigger and every job
+ * skips, the run reports success, and nothing says the suite did not execute.
+ *
+ * The corrected form is the same inversion that file prescribes: name the case
+ * that must NOT run — a pull request whose diff is irrelevant, or one from a
+ * fork that has no secrets — and let every other event through. So the rule is
+ * mechanical: no job condition in this workflow may test `github.event_name`
+ * for EQUALITY.
+ */
+describe('no job condition enumerates the events it will run on', () => {
+  const CONDITIONS = Object.entries(wf?.jobs ?? {})
+    .filter(([, job]) => job?.if !== undefined)
+    .map(([jobName, job]) => ({ jobName, condition: String(job.if) }))
+
+  it('finds the job conditions it means to check', () => {
+    expect(
+      CONDITIONS.map((entry) => entry.jobName),
+      `No job in ${WORKFLOW} carries an \`if:\`, so this check iterates nothing. Either the gating moved or the file was restructured.`,
+    ).not.toEqual([])
+  })
+
+  for (const { jobName, condition } of CONDITIONS) {
+    it(`${jobName} gates on what must not run, not on what may`, () => {
+      const allowlisted = [
+        ...condition.matchAll(/github\.event_name\s*==\s*'([^']*)'/g),
+      ].map((match) => match[1])
+      expect(
+        allowlisted,
+        `The \`if:\` on "${jobName}" enumerates the events it runs on:\n  if: ${condition}\nA trigger added later matches none of these clauses, so every job skips, the run reports success, and nothing indicates the suite did not execute — which is the failure this workflow already shipped once. Invert it: \`github.event_name != 'pull_request' || <the pull-request-only gate>\`.`,
+      ).toEqual([])
+    })
+  }
+})
diff --git a/scripts/__tests__/eql-workflow-filters.test.mjs b/scripts/__tests__/eql-workflow-filters.test.mjs
new file mode 100644
index 000000000..9857314c5
--- /dev/null
+++ b/scripts/__tests__/eql-workflow-filters.test.mjs
@@ -0,0 +1,232 @@
+import { execFileSync } from 'node:child_process'
+import yaml from 'js-yaml'
+import { describe, expect, it } from 'vitest'
+import { REPO_ROOT } from './lib/repo-root.mjs'
+import { readWorkflow } from './lib/workflows.mjs'
+
+/**
+ * The two EQL workflows decide what to run from a list of path globs, and both
+ * lists are written by hand more than once.
+ *
+ * `test-eql.yml` writes its list TWICE and in two different mechanisms: an
+ * `on: push: paths:` filter (which decides whether the workflow starts at all
+ * after a merge) and a `dorny/paths-filter` `relevant:` filter (which decides
+ * whether the heavy jobs run inside a pull-request run). GitHub gives no way to
+ * share them. `bench-eql.yml` writes a third copy, for the same tree, on its own
+ * `push` trigger.
+ *
+ * Three properties, and each of them was violated by the imported files:
+ *
+ * 1. THE COPIES AGREE. Same argument as `workflow-paths-filter-parity.test.mjs`
+ *    makes for the `push`/`pull_request` pair, one mechanism over: a filter that
+ *    loses an entry keeps reporting green, and the run it stops starting is the
+ *    one that would have caught the change.
+ *
+ * 2. NO GLOB IS DEAD. `packages/eql/sql/**` sat in the relevance filter from the
+ *    port onward and there is no such directory — the SQL lives in
+ *    `packages/eql/src/`. A glob that matches nothing narrows the filter by
+ *    exactly nothing while reading, to anyone auditing coverage, as though that
+ *    tree were covered. Compared against the real index, so a directory that is
+ *    RENAMED fails here rather than quietly stopping being an input.
+ *
+ * 3. THE COMPOSITE ACTIONS ARE COVERED. Both workflows invoke
+ *    `./.github/actions/require-cs-secrets`, whose job is to fail a credentialed
+ *    run in seconds. Neither filter listed it, so an edit that broke the
+ *    pre-flight ran in neither workflow. Discovered from each workflow's own
+ *    `uses:` edges rather than named here, so a second local action is covered
+ *    the day it is wired in.
+ *
+ * NOT COVERED, deliberately: whether the lists are COMPLETE. Nothing here can
+ * tell that `mise run postgres:up` reads `tests/docker-compose.yml`; that is
+ * read out of the task bodies by hand, and three such omissions are recorded in
+ * the comment above `bench-eql.yml`'s filter. What this file can guarantee is
+ * that the three lists stay one list, so the next such omission has to be made
+ * three times rather than once.
+ */
+
+const TEST_EQL = '.github/workflows/test-eql.yml'
+const BENCH_EQL = '.github/workflows/bench-eql.yml'
+
+/** `on:` parses as the boolean `true` under YAML 1.1 — the "Norway problem". */
+function triggers(wf) {
+  const on = wf?.on ?? wf?.[true]
+  return on && typeof on === 'object' ? on : {}
+}
+
+/** A workflow's `on.push.paths` list, or `[]`. */
+function pushPaths(relPath) {
+  const paths = triggers(readWorkflow(relPath))?.push?.paths
+  return Array.isArray(paths) ? paths : []
+}
+
+/**
+ * Every path listed by a `dorny/paths-filter` step, across every filter it
+ * declares. `filters:` is a YAML document embedded in a YAML string, so it is
+ * parsed rather than pattern-matched — a regex over the raw block would also
+ * match the commentary around it.
+ */
+function dornyFilterPaths(relPath) {
+  const wf = readWorkflow(relPath)
+  return Object.values(wf?.jobs ?? {})
+    .flatMap((job) => job?.steps ?? [])
+    .filter((step) =>
+      String(step?.uses ?? '').startsWith('dorny/paths-filter@'),
+    )
+    .flatMap((step) =>
+      Object.values(yaml.load(step?.with?.filters ?? '') ?? {}),
+    )
+    .flat()
+}
+
+/** The local composite actions a workflow reaches through `uses: ./…`. */
+function localActions(relPath) {
+  const wf = readWorkflow(relPath)
+  return [
+    ...new Set(
+      Object.values(wf?.jobs ?? {})
+        .flatMap((job) => job?.steps ?? [])
+        .map((step) => String(step?.uses ?? '').trim())
+        .filter((uses) => uses.startsWith('./.github/actions/'))
+        .map((uses) => uses.slice('./'.length)),
+    ),
+  ].sort()
+}
+
+/** Files git tracks under a pathspec. */
+function trackedUnder(pathspec) {
+  return execFileSync('git', ['ls-files', '-z', '--', pathspec], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  })
+    .split('\0')
+    .filter(Boolean)
+}
+
+/**
+ * Approximates picomatch, which is what `dorny/paths-filter` and GitHub's own
+ * `paths:` matcher are built on: `*` stops at a separator, `**` does not.
+ *
+ * No implicit-descendants tail here, unlike the `@actions/glob` approximation
+ * in `ffi-binding-action.test.mjs` — a bare directory name is NOT a prefix
+ * match in a `paths:` filter, which is the difference that makes a
+ * `.../require-cs-secrets` entry without its `/**` cover nothing.
+ */
+function globToRegExp(pattern) {
+  let source = '^'
+  for (let i = 0; i < pattern.length; i += 1) {
+    const ch = pattern[i]
+    if (ch === '*') {
+      if (pattern[i + 1] === '*') {
+        source += '.*'
+        i += 1
+        if (pattern[i + 1] === '/') i += 1
+      } else {
+        source += '[^/]*'
+      }
+    } else if (ch === '?') {
+      source += '[^/]'
+    } else {
+      source += ch.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    }
+  }
+  return new RegExp(`${source}$`)
+}
+
+const matches = (pattern, path) => globToRegExp(pattern).test(path)
+
+/** Everything in the index a filter entry could plausibly select. */
+const TRACKED = trackedUnder('.')
+
+/** The list each mechanism carries, keyed for the messages below. */
+const LISTS = [
+  { id: `${TEST_EQL} (on.push.paths)`, entries: pushPaths(TEST_EQL) },
+  { id: `${TEST_EQL} (dorny relevant:)`, entries: dornyFilterPaths(TEST_EQL) },
+  { id: `${BENCH_EQL} (on.push.paths)`, entries: pushPaths(BENCH_EQL) },
+]
+
+/**
+ * The workflow file each list is allowed to name, and the only entry that may
+ * differ between them: a filter naming its own workflow is not a copy of the
+ * same claim, it is each file saying "and me".
+ */
+const SELF_REFERENCES = new Set([TEST_EQL, BENCH_EQL])
+
+const shared = (entries) =>
+  entries.filter((entry) => !SELF_REFERENCES.has(entry)).sort()
+
+describe('the EQL path filters are three copies of one list', () => {
+  it('finds all three lists', () => {
+    // Each check below is "these lists agree" or "no entry violates X", and an
+    // empty list satisfies both for free. The `dorny` one is the fragile
+    // member — its `filters:` is YAML inside a YAML string, so a reformat can
+    // empty it without failing anything else.
+    for (const { id, entries } of LISTS) {
+      expect(
+        entries,
+        `${id} parsed to an empty list, so every comparison below is vacuous for it. Either the filter moved, or the shape this file reads it out of changed.`,
+      ).not.toEqual([])
+    }
+  })
+
+  it('names the same paths in every copy', () => {
+    const [reference, ...rest] = LISTS
+    for (const list of rest) {
+      expect(
+        shared(list.entries),
+        `The EQL path filters have diverged. ${list.id} and ${reference.id} answer the same question — "can this diff affect EQL?" — through mechanisms GitHub gives no way to share, so the list is written three times and nothing but this check keeps the copies together.\nThe silent direction is a DELETION from one copy: the workflows that still carry the entry keep running and keep reporting green, so the only signal is the run that stopped happening.\nIf a divergence is genuinely intended, it needs a different guard, not a wider one — the bench being a subset of the test suite's inputs is exactly the reasoning that produced the three drifted entries this list replaced.`,
+      ).toEqual(shared(reference.entries))
+    }
+  })
+
+  for (const { id, entries } of LISTS) {
+    it(`${id} lists no glob that matches nothing`, () => {
+      const dead = entries.filter(
+        (entry) => !TRACKED.some((file) => matches(entry, file)),
+      )
+      expect(
+        dead,
+        `These entries in ${id} match no file git tracks. A dead glob narrows the filter by nothing while reading as coverage of the tree it names — \`packages/eql/sql/**\` sat in this filter from the subtree import onward, and there is no such directory.\nEither fix the path, or delete the entry.`,
+      ).toEqual([])
+    })
+  }
+})
+
+describe('every composite action a workflow runs can trigger it', () => {
+  for (const relPath of [TEST_EQL, BENCH_EQL]) {
+    const actions = localActions(relPath)
+
+    it(`${relPath} runs at least one local composite action`, () => {
+      // The scan guard. Both workflows use `require-cs-secrets` today; if the
+      // discovery stops seeing it, the coverage check below iterates nothing
+      // and passes.
+      expect(
+        actions,
+        `No step in ${relPath} runs a \`./.github/actions/…\` composite action, so the coverage check below compares nothing. Either the action was inlined, or the \`uses:\` shape changed.`,
+      ).not.toEqual([])
+    })
+
+    it(`${relPath} triggers on a change to each of them`, () => {
+      // Every list this workflow gates on has to cover them: for test-eql that
+      // is the `push` filter AND the relevance filter, and an action edit that
+      // reached only one of the two would start the workflow and then skip
+      // every job inside it.
+      const lists = LISTS.filter((list) => list.id.startsWith(relPath))
+      expect(lists.length).toBeGreaterThan(0)
+
+      const uncovered = lists.flatMap(({ id, entries }) =>
+        actions
+          .filter(
+            (action) =>
+              !trackedUnder(action).every((file) =>
+                entries.some((entry) => matches(entry, file)),
+              ),
+          )
+          .map((action) => `${id} does not cover ${action}`),
+      )
+      expect(
+        uncovered,
+        `${relPath} runs these composite actions and does not trigger on a change to them. \`require-cs-secrets\` is the pre-flight that turns a rotated credential into a failure in seconds rather than one four minutes into a compile — an edit that breaks it must run the workflows that depend on it.\nAdd \`<action path>/**\` to every filter listed.`,
+      ).toEqual([])
+    })
+  }
+})
diff --git a/scripts/__tests__/ffi-binding-action.test.mjs b/scripts/__tests__/ffi-binding-action.test.mjs
index a50b4b574..a4a8076b4 100644
--- a/scripts/__tests__/ffi-binding-action.test.mjs
+++ b/scripts/__tests__/ffi-binding-action.test.mjs
@@ -38,7 +38,7 @@
  */
 import { execFileSync } from 'node:child_process'
 import { existsSync, readFileSync, statSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
+import { dirname, join, relative, resolve } from 'node:path'
 import yaml from 'js-yaml'
 import { describe, expect, it } from 'vitest'
 import { readJsonc } from './lib/read-jsonc.mjs'
@@ -354,6 +354,259 @@ describe('build-ffi-binding — the WASM key covers the build it skips', () => {
   })
 })
 
+/**
+ * The third question a cache key has to answer, and the one the two suites
+ * above cannot see: does it cover every crate the build COMPILES?
+ *
+ * Both of those reason about files inside `packages/protect-ffi`. Cargo does
+ * not. `crates/protect-ffi/Cargo.toml` carries
+ *
+ *     eql-bindings = { path = "../../../eql/crates/eql-bindings" }
+ *
+ * — an in-tree path dependency in a DIFFERENT package, and a genuine compile
+ * input to both `index.node` and the wasm32 build. A path dep carries no
+ * registry checksum, so a src-only edit under that crate touches nothing else:
+ * not `packages/protect-ffi/crates/**`, not either `Cargo.toml`, and not
+ * `Cargo.lock` (which records the path dep by name and version, and only moves
+ * when the version does). Every glob in both keys therefore hashes identically,
+ * the restore hits, `Build index.node (cargo)` is SKIPPED, and every
+ * credentialed job in CI proceeds on a binding compiled from the old crate.
+ *
+ * That is not hypothetical: across the three commits that shipped this
+ * dependency the crate's version moved 3.0.4 -> 4.0.0 -> 3.0.5 and neither
+ * cache key changed by a byte.
+ *
+ * DISCOVERED, not listed. The dependency set is read out of the manifest and
+ * followed transitively, so the second path dep — or one that moves — is held
+ * to the same bar the day it lands. A hand-written list would have been right
+ * on the commit that added it and silently wrong afterwards, which is the same
+ * failure shape one level down.
+ *
+ * `[dev-dependencies]` are deliberately NOT followed. `build:native` is
+ * `cargo build --release` and `build:wasm` is wasm-pack; neither compiles a
+ * dependency's dev-deps, so requiring them in the key would bust the cache on
+ * edits that cannot reach the artifact. (`eql-bindings` has one — `eql-domains`,
+ * its parity oracle — so this is a live distinction, not a hypothetical.)
+ */
+
+const CARGO_ROOT_CRATE = `${FFI_PKG}/crates/protect-ffi/Cargo.toml`
+
+/**
+ * The path dependencies declared by one Cargo manifest, as `{ name, path }`
+ * with `path` exactly as written.
+ *
+ * Deliberately a narrow reader over the text rather than a TOML parse: there is
+ * no TOML parser in this repo's dependency tree, and `cargo metadata` would put
+ * a Rust toolchain on `pnpm test:scripts` — which `packages/protect-ffi`'s
+ * `lintWiring.test.ts` exists to keep off the JS entry points.
+ *
+ * It reads both spellings cargo accepts: the inline table
+ * (`foo = { path = "..." }`) and the section form (`[dependencies.foo]` with a
+ * `path =` line beneath it). Sections are matched by their TAIL, so
+ * `[target.'cfg(not(target_arch = "wasm32"))'.dependencies]` is read the same
+ * as `[dependencies]` — the wasm and native halves of this crate declare
+ * different dependency sets and both compile.
+ *
+ * Exported shape is a pure function of the text so `the manifest reader is
+ * sound` below can exercise it on a literal, rather than on whatever the real
+ * manifest happens to say today.
+ */
+function parsePathDependencies(text) {
+  const found = []
+  let section = null
+  for (const raw of text.split('\n')) {
+    const line = raw.replace(/#.*$/, '').trim()
+    if (line === '') continue
+
+    const header = /^\[([^\]]+)\]$/.exec(line)
+    if (header) {
+      section = header[1]
+      continue
+    }
+    if (section === null) continue
+
+    // `[dependencies]`, `[build-dependencies]`, `[target.'…'.dependencies]`.
+    // `dev-dependencies` is excluded — see the note above the describe.
+    const isDepTable = /(^|\.)(build-)?dependencies$/.test(section)
+    // `[dependencies.foo]` / `[target.'…'.dependencies.foo]`
+    const namedDep = /(^|\.)(build-)?dependencies\.([A-Za-z0-9_-]+)$/.exec(
+      section,
+    )
+
+    if (isDepTable) {
+      const inline = /^([A-Za-z0-9_-]+)\s*=\s*\{(.*)\}$/.exec(line)
+      if (!inline) continue
+      const path = /\bpath\s*=\s*"([^"]+)"/.exec(inline[2])
+      if (path) found.push({ name: inline[1], path: path[1] })
+    } else if (namedDep) {
+      const path = /^path\s*=\s*"([^"]+)"$/.exec(line)
+      if (path) found.push({ name: namedDep[3], path: path[1] })
+    }
+  }
+  return found
+}
+
+/**
+ * Every crate `cargo build` compiles into the artifact, as repo-relative
+ * directories, starting from the cdylib crate and following path deps
+ * transitively. The starting crate itself is excluded: it lives under
+ * `packages/protect-ffi/crates/**`, which both keys already hash.
+ */
+function compiledPathDependencies(rootManifestRel) {
+  const crates = new Map()
+  const unresolved = []
+  const queue = [rootManifestRel]
+  const seen = new Set([rootManifestRel])
+
+  while (queue.length > 0) {
+    const manifestRel = queue.shift()
+    const full = resolve(REPO_ROOT, manifestRel)
+    if (!existsSync(full)) {
+      unresolved.push(manifestRel)
+      continue
+    }
+    for (const dep of parsePathDependencies(readFileSync(full, 'utf8'))) {
+      const dirRel = relative(
+        REPO_ROOT,
+        resolve(dirname(full), dep.path),
+      ).replaceAll('\\', '/')
+      const depManifest = `${dirRel}/Cargo.toml`
+      if (!crates.has(dirRel)) crates.set(dirRel, dep.name)
+      if (seen.has(depManifest)) continue
+      seen.add(depManifest)
+      queue.push(depManifest)
+    }
+  }
+  return {
+    crates: [...crates.entries()].map(([dir, name]) => ({ dir, name })),
+    unresolved,
+  }
+}
+
+/**
+ * The nearest ancestor manifest declaring `[workspace]` — the file cargo reads
+ * for the crate's workspace context, and the one a `foo.workspace = true` key
+ * inherits from. `eql-bindings` inherits nothing today, and three of its four
+ * siblings inherit `[lints]`, so the file is one `workspace = true` away from
+ * being a compile input for this crate too.
+ */
+function workspaceRootOf(dirRel) {
+  let current = dirRel
+  while (current !== '' && current !== '.') {
+    const candidate = `${current}/Cargo.toml`
+    const full = resolve(REPO_ROOT, candidate)
+    if (
+      existsSync(full) &&
+      /^\s*\[workspace\]/m.test(readFileSync(full, 'utf8'))
+    ) {
+      return candidate
+    }
+    current = dirname(current)
+  }
+  return null
+}
+
+const COMPILED = compiledPathDependencies(CARGO_ROOT_CRATE)
+
+/** Which of this action's cache steps must cover a Rust compile input. */
+const RUST_CACHE_STEPS = cacheSteps.map((step, idx) => ({
+  step,
+  name: label(step, idx),
+}))
+
+describe('build-ffi-binding — the keys cover every crate the build compiles', () => {
+  it('the manifest reader is sound', () => {
+    // The discovery below is only as good as this. An over-accepting reader
+    // that returned nothing would make every check that follows vacuous, and a
+    // reader that missed the `[target.'cfg(…)'.dependencies]` form would miss
+    // exactly the half of this crate that only the wasm build compiles.
+    const deps = parsePathDependencies(`
+      [package]
+      name = "example"
+      path = "not-a-dependency"
+
+      [dependencies]
+      registry-only = "1.0"
+      inline = { path = "../inline", version = "1" }
+
+      [dev-dependencies]
+      oracle = { path = "../oracle" }
+
+      [build-dependencies]
+      codegen = { path = "../codegen" }
+
+      [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+      native = { path = "../native" }
+
+      [dependencies.sectioned]
+      path = "../sectioned"
+    `)
+    expect(deps).toEqual([
+      { name: 'inline', path: '../inline' },
+      { name: 'codegen', path: '../codegen' },
+      { name: 'native', path: '../native' },
+      { name: 'sectioned', path: '../sectioned' },
+    ])
+  })
+
+  it('found the path dependencies it means to check', () => {
+    expect(
+      COMPILED.unresolved,
+      `These manifests are named by a \`path = \` dependency and do not exist. A path dep cargo cannot resolve does not build at all, so this is a broken manifest rather than a broken guard.`,
+    ).toEqual([])
+
+    expect(
+      COMPILED.crates.map((crate) => crate.dir),
+      `\`${CARGO_ROOT_CRATE}\` declares no path dependencies, so every assertion below iterates nothing and passes having checked nothing. If the in-tree crate moved to a registry pin, this guard is obsolete — but read \`scripts/lint-no-eql-registry-pins.mjs\` first, which exists to stop exactly that.`,
+    ).not.toEqual([])
+
+    for (const crate of COMPILED.crates) {
+      expect(
+        trackedUnder(crate.dir).length,
+        `${crate.dir} (\`${crate.name}\`) has no git-tracked files, so the coverage check below has nothing to compare against.`,
+      ).toBeGreaterThan(0)
+    }
+  })
+
+  for (const { step, name } of RUST_CACHE_STEPS) {
+    it(`"${name}" hashes every crate the build compiles`, () => {
+      const patterns = hashFilesPatterns(step?.with?.key)
+      const uncovered = COMPILED.crates.flatMap((crate) =>
+        trackedUnder(crate.dir).filter(
+          (file) => !patterns.some((pattern) => globMatches(pattern, file)),
+        ),
+      )
+      expect(
+        uncovered,
+        `These files are compiled into the artifact this step caches and are absent from its key, so an edit to one leaves the key unchanged, the restore hits, and the build step is skipped over a stale binary. A path dependency carries no registry checksum and does not move \`Cargo.lock\` on a source-only edit, so nothing else in the key covers it either.\nAdd a glob for each crate to the \`hashFiles(...)\` list on the "${name}" step.`,
+      ).toEqual([])
+    })
+
+    it(`"${name}" hashes the workspace root of every out-of-tree crate`, () => {
+      const patterns = hashFilesPatterns(step?.with?.key)
+      const roots = [
+        ...new Set(
+          COMPILED.crates
+            .map((crate) => workspaceRootOf(crate.dir))
+            .filter(Boolean),
+        ),
+      ]
+      expect(
+        roots,
+        'No path dependency resolved to a crate inside a Cargo workspace, so this check compares nothing.',
+      ).not.toEqual([])
+
+      const uncovered = roots.filter(
+        (root) => !patterns.some((pattern) => globMatches(pattern, root)),
+      )
+      expect(
+        uncovered,
+        `Cargo reads these workspace manifests to resolve the path dependencies above — a \`<key>.workspace = true\` in a dependency crate inherits from here, and \`[patch]\` is read from here too. They are build inputs on the same footing as the crate sources, and neither is covered by \`${FFI_PKG}\`'s own manifests.\nAdd each to the \`hashFiles(...)\` list on the "${name}" step.`,
+      ).toEqual([])
+    })
+  }
+})
+
 describe('jdx/mise-action is pinned to an immutable commit', () => {
   const files = [ACTION, RUST_WORKFLOW]
 
diff --git a/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs b/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs
index e1ea3565d..3fc7dee8d 100644
--- a/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs
+++ b/scripts/__tests__/workflow-dispatch-job-conditions.test.mjs
@@ -559,8 +559,9 @@ describe('the fork-PR guard keeps its meaning', () => {
       // Every context, then narrowed to the ones this workflow can actually be
       // in. A workflow with no `push:` trigger is never evaluated on a push, so
       // requiring `push: true` there would be asserting about a run that cannot
-      // happen — and `test-eql.yml` deliberately has no `push:` (its merge queue
-      // already validated the exact merge commit).
+      // happen. (`test-eql.yml` carried no `push:` when this was written,
+      // justified by a merge queue that does not exist in this repository; it
+      // has one now, and this narrowing simply picks the trigger up.)
       //
       // `workflow_dispatch` is the exception and stays unconditional: this file
       // exists because a job silently skipped on a dispatch that WAS declared,
diff --git a/scripts/__tests__/workflow-paths-filter-parity.test.mjs b/scripts/__tests__/workflow-paths-filter-parity.test.mjs
index 83cb4fc90..d9557fb18 100644
--- a/scripts/__tests__/workflow-paths-filter-parity.test.mjs
+++ b/scripts/__tests__/workflow-paths-filter-parity.test.mjs
@@ -116,6 +116,24 @@ const EXPECTED_ASYMMETRIES = new Map([
     // release machinery never runs the check) is what the single list IS.
     'pull_request is the only trigger; a post-merge copy would report a release-blocking finding too late to act on',
   ],
+  [
+    '.github/workflows/test-eql.yml',
+    // `pull_request` is deliberately UNFILTERED and `push: branches: [main]`
+    // carries the list, which is the same shape as tests-rust.yml with the two
+    // events swapped. Unfiltered on the PR side because this workflow's
+    // `ci-required` is the check branch protection is meant to reference, and a
+    // workflow skipped by a path filter leaves a required check stuck Pending;
+    // relevance is applied per-job via `if:` instead. Filtered on the push side
+    // because nothing waits on a push run, so skipping one costs nothing.
+    //
+    // The direction that would hurt — a `pull_request` filter narrower than the
+    // `push` one, so the PR introducing a change never runs the suite — is
+    // unreachable when `pull_request` has no filter at all. The push list is
+    // not unchecked: `eql-workflow-filters.test.mjs` compares it against the
+    // `relevant:` filter in the `changes` job, which is the second copy of the
+    // same list and the one this file cannot see.
+    'pull_request is deliberately unfiltered (per-job relevance instead), so PRs run a superset of what push runs; the push list is compared against the `changes` job filter by eql-workflow-filters.test.mjs',
+  ],
   [
     '.github/workflows/bench-eql.yml',
     // The mirror image of lint-release.yml: `push: branches: [main]` with a
diff --git a/scripts/__tests__/workflow-run-fail-fast.test.mjs b/scripts/__tests__/workflow-run-fail-fast.test.mjs
new file mode 100644
index 000000000..18481163e
--- /dev/null
+++ b/scripts/__tests__/workflow-run-fail-fast.test.mjs
@@ -0,0 +1,263 @@
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { REPO_ROOT } from './lib/repo-root.mjs'
+import { readWorkflow, workflowFiles } from './lib/workflows.mjs'
+
+/**
+ * A multi-command `run:` block under a CUSTOM shell must turn on errexit
+ * itself, because GitHub does not turn it on for it.
+ *
+ * For the built-in `shell: bash`, GitHub runs `bash --noprofile --norc -eo
+ * pipefail {0}` — the `-e` is there, and a failing command anywhere in the
+ * block fails the step. Write `shell: bash {0}` instead and you get exactly the
+ * flags you asked for, which is none of them. The block then runs to the end
+ * regardless and the step reports only the LAST command's exit code.
+ *
+ * Every EQL workflow imported with the subtree carries
+ * `defaults.run.shell: bash {0}`, so this applied to all three files at once,
+ * and it fails in the silent direction. Two live instances, both of them a
+ * build followed by the check that inspects what the build produced:
+ *
+ *   test-eql.yml, "Clean-DB v3 install smoke"
+ *     mise run clean && mise run build
+ *     mise run test:clean_install_v3
+ *
+ *   macro-expand-eql.yml, "Regenerate and verify the matrix expansion snapshots"
+ *     mise run test:matrix:expand
+ *     git diff --exit-code -- … || { echo "…stale…"; exit 1; }
+ *
+ * In both, a failing FIRST line is discarded and the second line decides the
+ * step. In the second the second line is a drift check against files the first
+ * line was supposed to regenerate — so when the regeneration breaks, the
+ * snapshots are unchanged, the diff is clean, and the job goes green having
+ * verified that a build which did not happen produced no change.
+ *
+ * `test-eql.yml`'s "Verify the matrix test-name inventory" already carried
+ * `set -euo pipefail` with a comment explaining exactly this. That comment is
+ * the evidence the hazard was understood and the fix applied one step at a
+ * time; this file is what applies it to the rest.
+ *
+ * ERREXIT ONLY, not pipefail. Errexit is what the defect is about, and pipefail
+ * is not always safe to add retroactively: a `grep … | head -1` reports 141
+ * under pipefail when the reader closes early, which is the SIGPIPE hazard
+ * `workflow-grep-q-pipelines.test.mjs` documents at length. Requiring `-e` and
+ * leaving `-o pipefail` to judgement keeps this guard from pushing anyone into
+ * that one.
+ *
+ * SINGLE-COMMAND BLOCKS ARE EXEMPT, and that is not a loophole: the step's exit
+ * code IS that command's, so errexit changes nothing. Only blocks with more
+ * than one top-level command can lose a status.
+ */
+
+/** Composite actions run the same shells and are part of the same call tree. */
+function actionManifests() {
+  const dir = '.github/actions'
+  return readdirSync(join(REPO_ROOT, dir), { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => `${dir}/${entry.name}/action.yml`)
+    .sort()
+}
+
+/**
+ * Every `run:` step, with the shell that will actually execute it.
+ *
+ * Resolution order is GitHub's: the step's own `shell:`, then the job's
+ * `defaults.run.shell`, then the workflow's. A composite action has no
+ * defaults — `shell:` is required on each step there — so the same walk with
+ * two empty levels is correct rather than merely convenient.
+ */
+function runSteps(doc, file) {
+  const workflowShell = doc?.defaults?.run?.shell
+  const fromJobs = Object.entries(doc?.jobs ?? {}).flatMap(([jobId, job]) =>
+    (job?.steps ?? [])
+      .filter((step) => typeof step?.run === 'string')
+      .map((step) => ({
+        file,
+        where: `${jobId} › ${step.name ?? step.id ?? '(unnamed)'}`,
+        run: step.run,
+        shell: step.shell ?? job?.defaults?.run?.shell ?? workflowShell,
+      })),
+  )
+  const fromAction = (doc?.runs?.steps ?? [])
+    .filter((step) => typeof step?.run === 'string')
+    .map((step) => ({
+      file,
+      where: step.name ?? step.id ?? '(unnamed)',
+      run: step.run,
+      shell: step.shell,
+    }))
+  return [...fromJobs, ...fromAction]
+}
+
+/**
+ * A shell template — anything containing the `{0}` script placeholder. That
+ * placeholder is precisely what turns a shell KEYWORD (for which GitHub supplies
+ * its own flags) into a custom command line (for which it supplies none).
+ */
+const isCustomShell = (shell) => /\{0\}/.test(String(shell ?? ''))
+
+/** Errexit, in every spelling: `-e`, `-eo`, `-euo`, `-o errexit`. */
+const ERREXIT = /(?:^|\s)(?:-[a-zA-Z]*e[a-zA-Z]*|-o\s+errexit)(?:\s|$)/
+
+/** Does the custom shell command line itself ask for errexit? */
+const shellSetsErrexit = (shell) =>
+  ERREXIT.test(String(shell ?? '').replace(/\{0\}/, ''))
+
+/** Does the script turn errexit on before doing anything? */
+const scriptSetsErrexit = (run) =>
+  String(run)
+    .split('\n')
+    .some((line) => /^\s*set\s+/.test(line) && ERREXIT.test(line))
+
+/**
+ * The top-level commands in a script.
+ *
+ * Continuations are joined — a trailing `\`, and a line ending in `&&`, `||`,
+ * `|` or `;` — because those are one command spread over several lines and
+ * cannot lose a status between them. Comments and blank lines are dropped.
+ *
+ * Block keywords (`if`/`fi`, `for`/`done`, `case`/`esac`) are deliberately NOT
+ * collapsed. A four-line `if` counts as four, and so needs `set -e` it does not
+ * strictly require. That over-strictness is chosen: recognising shell blocks
+ * means parsing shell, the parser is what would be wrong, and the cost of being
+ * wrong in this direction is one line at the top of a script that is better for
+ * having it.
+ */
+function topLevelCommands(script) {
+  const commands = []
+  let pending = ''
+  let continued = false
+  for (const raw of String(script).split('\n')) {
+    const line = raw.trim()
+    if (line === '' || line.startsWith('#')) continue
+    pending = continued ? `${pending} ${line}` : line
+    continued = /(?:\\|&&|\|\||\||;)$/.test(line)
+    if (!continued) {
+      commands.push(pending)
+      pending = ''
+    }
+  }
+  if (pending !== '') commands.push(pending)
+  return commands
+}
+
+const FILES = [...workflowFiles(), ...actionManifests()]
+
+const CUSTOM_SHELL_STEPS = FILES.flatMap((file) =>
+  runSteps(readWorkflow(file), file).filter((step) =>
+    isCustomShell(step.shell),
+  ),
+)
+
+const MULTI_COMMAND = CUSTOM_SHELL_STEPS.filter(
+  (step) => topLevelCommands(step.run).length > 1,
+)
+
+const stepId = (step) => `${step.file} › ${step.where}`
+
+/**
+ * Steps that legitimately must NOT fail fast, each with the reason. Empty
+ * today and intended to stay that way — a step that wants to continue past a
+ * failing command should say so at that command (`… || true`) rather than by
+ * leaving errexit off for the whole block, because the second form also
+ * swallows the failures nobody chose to tolerate.
+ *
+ * The stale check below deletes an entry the moment it stops matching a
+ * multi-command custom-shell step, so an exemption cannot outlive the step it
+ * was written for.
+ */
+const FAIL_FAST_EXEMPT = new Map([
+  // ['<file> › <job> › <step>', 'why this block must run past a failing command'],
+])
+
+describe('multi-command run: blocks under a custom shell fail fast', () => {
+  it('finds workflows and composite actions to check', () => {
+    expect(FILES.length).toBeGreaterThan(0)
+  })
+
+  it('finds the custom-shell steps this guard exists for', () => {
+    // `shell: bash {0}` is what drops GitHub's implicit `-eo pipefail`. If no
+    // step uses a custom shell the property is vacuous — which would be a fine
+    // state of the world, but not one to reach silently, since the three EQL
+    // workflows set it at `defaults.run` level where it is easy to lose.
+    expect(
+      CUSTOM_SHELL_STEPS.map(stepId),
+      'No `run:` step in the repository resolves to a custom shell (one containing `{0}`), so this file checks nothing. If the EQL workflows dropped `defaults.run.shell: bash {0}` in favour of the `bash` keyword, that is the better fix and this guard is obsolete — delete it deliberately.',
+    ).not.toEqual([])
+  })
+
+  it('finds multi-command ones among them', () => {
+    // The narrower floor, and the one that actually guards the check below:
+    // single-command blocks are exempt by construction, so a scan that found
+    // only those would iterate nothing while looking healthy.
+    expect(
+      MULTI_COMMAND.map(stepId),
+      'Every custom-shell `run:` block in the repository is a single command, so the errexit check below compares nothing. Verify that is really the case before deleting this floor — `topLevelCommands` joining too eagerly looks identical from here.',
+    ).not.toEqual([])
+  })
+
+  it('turns errexit on in every one', () => {
+    const offenders = MULTI_COMMAND.filter(
+      (step) =>
+        !shellSetsErrexit(step.shell) &&
+        !scriptSetsErrexit(step.run) &&
+        !FAIL_FAST_EXEMPT.has(stepId(step)),
+    ).map(
+      (step) =>
+        `  ${stepId(step)}\n    shell: ${step.shell}\n    ${topLevelCommands(step.run).length} top-level commands, first: ${topLevelCommands(step.run)[0]}`,
+    )
+
+    expect(
+      offenders,
+      `These \`run:\` blocks run several commands under a shell that was NOT given \`-e\`, so a failure in any but the last is discarded and the step reports the last command's status.\nThe direction it fails in is the dangerous one: a build followed by a check that inspects the build's output goes GREEN when the build breaks, because the output it checks is simply unchanged.\nAdd \`set -euo pipefail\` as the first line (or \`set -eu\` where a pipeline into an early-exiting reader makes pipefail a SIGPIPE hazard — see \`workflow-grep-q-pipelines.test.mjs\`), or put \`-eo pipefail\` on the shell line itself.\n${offenders.join('\n')}`,
+    ).toEqual([])
+  })
+
+  it('keeps no stale exemptions', () => {
+    const live = new Set(MULTI_COMMAND.map(stepId))
+    const stale = [...FAIL_FAST_EXEMPT.keys()].filter((id) => !live.has(id))
+    expect(
+      stale,
+      'These FAIL_FAST_EXEMPT entries no longer name a multi-command custom-shell step. If the step was fixed or collapsed to one command, delete the entry — it now exempts nothing while reading as deliberate, and hides the next one.',
+    ).toEqual([])
+  })
+})
+
+describe('the command counter this guard depends on', () => {
+  // A counter that returns 1 for everything makes the check above unfailable,
+  // and it would look exactly as green as it does now.
+  it('counts a single command as one, however it is spread', () => {
+    expect(topLevelCommands('mise run build')).toHaveLength(1)
+    expect(topLevelCommands('# a comment\n\nmise run build\n')).toHaveLength(1)
+    expect(topLevelCommands('mise run clean && mise run build')).toHaveLength(1)
+    expect(topLevelCommands('cat file \\\n  | psql \\\n  -f-')).toHaveLength(1)
+    expect(
+      topLevelCommands('git diff --exit-code -- a b \\\n  || exit 1'),
+    ).toHaveLength(1)
+  })
+
+  it('counts commands on separate lines separately', () => {
+    expect(
+      topLevelCommands('mise run clean && mise run build\nmise run test'),
+    ).toHaveLength(2)
+  })
+
+  it('recognises errexit in the spellings CI uses', () => {
+    expect(scriptSetsErrexit('set -e\nfoo')).toBe(true)
+    expect(scriptSetsErrexit('set -euo pipefail\nfoo')).toBe(true)
+    expect(scriptSetsErrexit('set -eu\nfoo')).toBe(true)
+    expect(scriptSetsErrexit('set -o errexit\nfoo')).toBe(true)
+    // The near-misses that must NOT count: pipefail alone leaves a failing
+    // non-final command discarded exactly as before.
+    expect(scriptSetsErrexit('set -o pipefail\nfoo')).toBe(false)
+    expect(scriptSetsErrexit('set -u\nfoo')).toBe(false)
+    expect(scriptSetsErrexit('foo\nbar')).toBe(false)
+    // And a shell line that already carries it makes the script's own `set`
+    // unnecessary — this is how the built-in `bash` keyword behaves.
+    expect(shellSetsErrexit('bash --noprofile --norc -eo pipefail {0}')).toBe(
+      true,
+    )
+    expect(shellSetsErrexit('bash {0}')).toBe(false)
+  })
+})

From fd8c40b1cdfe210c1a99e78912d9d582705b2dc5 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:26:26 +1000
Subject: [PATCH 11/20] test(eql): the cargo-task guard was reading 32 of 73
 tasks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The guard exists so that a mise task invoking cargo cannot go unreached by
CI — "a check nothing invokes reads exactly like a check that passes". Its
scan missed 41 of 73 tasks, so the property held over less than half the
surface it named.

Three blind spots, established empirically against mise in a scratch
project rather than inferred:

  * BARE TABLE HEADERS. In a config pulled in by `[task_config].includes`,
    every top-level table is a task — `["postgres:up"]`, not
    `[tasks."postgres:up"]`, which is a hard parse error there. The regex
    required the latter, so tasks/postgres.toml and tasks/fixtures.toml
    contributed 0 of their 6.
  * FILE TASKS. `includes = ["tasks", ...]` makes every executable under
    tasks/** a task. None were parsed. The inclusion rule is the executable
    bit and nothing else — it correctly excludes the `source`d helpers, the
    `bash tasks/...`-invoked scripts, *.sql and *.txt, while including
    githooks/pre-commit (no extension) and xml-to-json.py.
  * NAME COLLISIONS. Where a file task's stem is already claimed by a TOML
    task, mise keeps the extension: tasks/test/known-failures.sh becomes
    `test:known-failures.sh`. Collapsing those would have silently replaced
    the task CI actually runs.

MUTATION-PROVEN: deleting bench-eql.yml passed all 14 tests. `test:bench`
is a file task, so removing its only caller was invisible — the exact
"suite goes quiet" failure this file exists to prevent. That case is now a
permanent test: `reachableFrom` takes the workflow list as a parameter, so
the mutation is injected rather than performed, and a SOLE_CALLER_WORKFLOWS
equality recomputes reachability with each workflow removed in turn.

The floors could not have caught any of it — mise.toml alone carries 32
tasks against a `>= 30` floor. Replaced with per-source assertions: every
config in `includes` must contribute at least one task, and so must the
file walk.

Two defects found while fixing it. The naive `mise run` body scan created
FALSE reachability, staling `test:sqlx`'s exemption off a comment in
fixtures.toml; and scriptBodies inlined scripts named in `#MISE sources`
comments, falsely clearing `release:prepare-bindings-assets`. Of 56 `mise
run` occurrences, only 20 are commands.

Four new orphans, all exempted with reasons. `test:lint` is not a reflexive
exemption: it is `cargo fmt --check` scoped to tests/sqlx, and `cargo fmt
--check -v` at the workspace root lists those files, so `test:crates` is a
strict superset. `docs:generate:json` gets a new self-expiring category —
blocked on an unported workflow — which the staleness check will demand be
removed the day _build-docs.yml is ported.
---
 scripts/__tests__/eql-suite-ci.test.mjs | 685 +++++++++++++++++++++---
 1 file changed, 597 insertions(+), 88 deletions(-)

diff --git a/scripts/__tests__/eql-suite-ci.test.mjs b/scripts/__tests__/eql-suite-ci.test.mjs
index e030ecb78..ca1bd1947 100644
--- a/scripts/__tests__/eql-suite-ci.test.mjs
+++ b/scripts/__tests__/eql-suite-ci.test.mjs
@@ -1,6 +1,6 @@
 import { execFileSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
 import yaml from 'js-yaml'
 import { describe, expect, it } from 'vitest'
 import { REPO_ROOT } from './lib/repo-root.mjs'
@@ -35,6 +35,13 @@ import { readWorkflow, WORKFLOW_DIR, workflowFiles } from './lib/workflows.mjs'
 /** The EQL suite's own workflow, at the only path GitHub reads. */
 const EQL_WORKFLOW = `${WORKFLOW_DIR}/test-eql.yml`
 
+/**
+ * The nightly/push-only bench workflow, named because it is the SOLE caller of
+ * a cargo check (`test:bench`) and therefore the subject of the mutation test
+ * at the bottom of this file.
+ */
+const BENCH_WORKFLOW = `${WORKFLOW_DIR}/bench-eql.yml`
+
 /** A `.github` deposited inside the package by the subtree import. */
 const DEAD_GITHUB_DIR = 'packages/eql/.github'
 
@@ -142,16 +149,35 @@ describe('the relevance filter still selects the imported tree', () => {
     ).not.toEqual([])
   })
 
+  /**
+   * The composite actions this workflow reaches through `uses: ./…`.
+   *
+   * They are the second legitimate class of non-subtree path, alongside the
+   * workflow's own file: `require-cs-secrets` lives at the repository root, and
+   * a change to it changes what every credentialed EQL job does — so it belongs
+   * in the relevance filter. Derived from the `uses:` edges rather than
+   * allowlisted by name, so adding an action to the workflow and to the filter
+   * needs no edit here, while an unrelated root path still fails.
+   */
+  const localActionPrefixes = Object.values(wf?.jobs ?? {})
+    .flatMap((job) => job?.steps ?? [])
+    .map((step) => step?.uses ?? '')
+    .filter((uses) => uses.startsWith('./'))
+    .map((uses) => `${uses.slice('./'.length)}/`)
+
   it('prefixes every source path with the subtree root', () => {
-    // The workflow's own path is the one legitimate exception: it lives at the
-    // repository root, not inside the subtree.
+    // Two legitimate exceptions, both outside the subtree by nature: the
+    // workflow's own path, and a composite action it `uses:`.
     const offenders = filterPaths.filter(
-      (path) => path !== EQL_WORKFLOW && !path.startsWith(EQL_PREFIX),
+      (path) =>
+        path !== EQL_WORKFLOW &&
+        !path.startsWith(EQL_PREFIX) &&
+        !localActionPrefixes.some((prefix) => path.startsWith(prefix)),
     )
 
     expect(
       offenders,
-      `These \`paths:\` entries in ${EQL_WORKFLOW} are not under \`${EQL_PREFIX}\`. dorny/paths-filter matches repo-root-relative paths, so after the subtree import an unprefixed glob matches the WRONG tree — \`src/**\` selects \`packages/stack/src/**\` and never \`packages/eql/src/**\`. The heavy jobs then skip on real EQL changes, report \`skipped\`, and \`ci-required\` treats skipped as pass.\n${offenders.map((p) => `  ${p}`).join('\n')}`,
+      `These \`paths:\` entries in ${EQL_WORKFLOW} are not under \`${EQL_PREFIX}\`, are not the workflow itself, and are not a composite action it \`uses:\`. dorny/paths-filter matches repo-root-relative paths, so after the subtree import an unprefixed glob matches the WRONG tree — \`src/**\` selects \`packages/stack/src/**\` and never \`packages/eql/src/**\`. The heavy jobs then skip on real EQL changes, report \`skipped\`, and \`ci-required\` treats skipped as pass.\n${offenders.map((p) => `  ${p}`).join('\n')}`,
     ).toEqual([])
   })
 
@@ -187,20 +213,111 @@ describe('the relevance filter still selects the imported tree', () => {
  * CI itself.
  *
  * So this asserts the property one level up: a mise task that compiles or runs
- * Rust must be reached by some workflow GitHub actually executes. Fifteen tasks
- * qualify, and they arrived from a repository where a different set of
+ * Rust must be reached by some workflow GitHub actually executes. Twenty-six
+ * tasks qualify, and they arrived from a repository where a different set of
  * workflows ran them — which is exactly the state in which one goes quiet
  * without anyone noticing.
+ *
+ * ## Why the scan is as long as it is
+ *
+ * The first version of it parsed one shape (`[tasks."name"]`) out of three
+ * hard-coded files and closed reachability over `depends` alone. That missed
+ * three whole classes of task, and the floors it guarded itself with — "at
+ * least 30 tasks", "at least 18 cargo tasks" — were satisfiable by
+ * `packages/eql/mise.toml` on its own, so the two configs contributing NOTHING
+ * were invisible. Mutation-tested: with that scan in place, deleting
+ * `bench-eql.yml` (the sole caller of `test:bench`) left all 14 assertions
+ * green. Everything below exists because of one of those three classes.
  */
 
-const MISE_CONFIGS = [
-  'packages/eql/mise.toml',
-  'packages/eql/tasks/fixtures.toml',
-  'packages/eql/tasks/postgres.toml',
-]
+/** The imported package, and mise's entry point inside it. */
+const EQL_PACKAGE = 'packages/eql'
+const MISE_TOML = `${EQL_PACKAGE}/mise.toml`
+
+const readRepo = (relPath) => readFileSync(join(REPO_ROOT, relPath), 'utf8')
+
+/** The `["a", 'b']` inside a TOML array, without a TOML parser. */
+const parseStringArray = (inner) =>
+  [...inner.matchAll(/"([^"]+)"|'([^']+)'/g)].map((m) => m[1] ?? m[2])
+
+/**
+ * `[task_config].includes`, read rather than hard-coded.
+ *
+ * The list used to be a `MISE_CONFIGS` const here, which is a copy of a
+ * declaration that lives in mise.toml — and the failure mode of a stale copy is
+ * the one this file is about: a fourth config lands, this scan never opens it,
+ * and every task in it becomes unguarded silently. Reading the real list means
+ * a new entry is covered the day it is added; `TASK_SOURCES` below then insists
+ * each entry actually yielded a task, so an entry that resolves to nothing
+ * fails rather than contributing nothing.
+ */
+function parseIncludes(miseText) {
+  const section = /^\[task_config\][^\n]*\n([\s\S]*?)(?=^\[|$)/m.exec(miseText)
+  const array = /^includes\s*=\s*\[([^\]]*)\]/m.exec(section?.[1] ?? '')
+  return array ? parseStringArray(array[1]) : []
+}
+
+/**
+ * mise's task blocks, without a TOML parser.
+ *
+ * Adding one is an audit decision in this repo, and the shape needed here is
+ * small: a table header, an optional `depends = [...]`, and the body text.
+ *
+ * The two dialects are NOT interchangeable, and merging them would be wrong in
+ * both directions. In `mise.toml` a task is `[tasks."name"]` and a bare
+ * `[settings]` / `[tools]` / `[env]` table is configuration. In a file named by
+ * `includes` the whole document is tasks, so EVERY top-level table is a task
+ * name and `[tasks."name"]` is not a task at all — mise rejects the file with
+ * "unknown field `name`, expected one of `description`, `alias`, …". That is
+ * why `tasks/postgres.toml` writes `["postgres:up"]` and `tasks/fixtures.toml`
+ * writes `["fixture:generate:all"]`, and why the old single regex parsed 0 of
+ * their 6 tasks.
+ */
+function parseTomlTasks(text, { bareTables }) {
+  const header = bareTables
+    ? /^\[(?:"([^"]+)"|([\w:.-]+))\]/
+    : /^\[tasks\.(?:"([^"]+)"|([\w:.-]+))\]/
+  return text
+    .split(/^(?=\[)/m) // split on top-level table headers; keep header + body
+    .map((block) => ({ match: header.exec(block), block }))
+    .filter(({ match }) => match)
+    .map(({ match, block }) => ({ name: match[1] ?? match[2], block }))
+}
 
 /**
- * The scripts a task block delegates to, inlined.
+ * A task's `depends`, from either dialect.
+ *
+ * TOML tasks spell it `depends = ["build"]`. FILE tasks spell it as a header
+ * comment, `#MISE depends=["build"]` — `tasks/docs/validate/source.sh` and
+ * three siblings carry one, and it is a real edge: without it those tasks are
+ * unreachable-from and `build` loses a caller.
+ */
+function parseDepends(text) {
+  const m = /^[ \t]*(?:#MISE[ \t]+)?depends\s*=\s*\[([^\]]*)\]/m.exec(text)
+  return m ? parseStringArray(m[1]) : []
+}
+
+/**
+ * Comment lines, in both TOML and shell. Prose is not a step — see `invokes`
+ * and `scriptBodies`, which both read a body only after this has run.
+ *
+ * Memoised on the exact input string. The mutation test below re-runs the whole
+ * reachability walk once per workflow, so this is called tens of thousands of
+ * times over the same ~100 bodies; without the cache that test spends most of a
+ * second re-stripping text and starts flaking against vitest's 5s timeout.
+ */
+const strippedBodies = new Map()
+function stripCommentLines(text) {
+  let stripped = strippedBodies.get(text)
+  if (stripped === undefined) {
+    stripped = text.replace(/^[ \t]*#.*$/gm, '')
+    strippedBodies.set(text, stripped)
+  }
+  return stripped
+}
+
+/**
+ * The scripts a task delegates to, inlined.
  *
  * Most of EQL's heavier tasks are one line — `run = "bash tasks/test/foo.sh"` —
  * and every cargo invocation lives in the script. Reading only the block would
@@ -209,96 +326,255 @@ const MISE_CONFIGS = [
  * class of task most worth checking. One hop is enough: no script here invokes
  * another via a second `tasks/` path.
  *
+ * Comment lines are stripped first, and that is not cosmetic. `tasks/build.sh`
+ * lists eight sibling scripts in a `#MISE sources=[…]` header (cache-
+ * invalidation inputs, not delegations) and `prepare-bindings-assets.sh`
+ * mentions `tasks/build.sh` in prose. Inlining those makes a task look like it
+ * shells to cargo when it does not — `release:prepare-bindings-assets` was
+ * reported as an unreached cargo check on the strength of one comment.
+ *
  * A path that does not resolve contributes nothing rather than throwing — a
  * task naming a script that does not exist is a different defect, and mise
  * fails loudly on it.
  */
-function scriptBodies(block) {
-  const paths = [...block.matchAll(/\btasks\/[\w./-]+\.sh\b/g)].map((m) => m[0])
-  return paths
-    .map((rel) => {
-      const abs = join(REPO_ROOT, 'packages/eql', rel)
-      return existsSync(abs) ? readFileSync(abs, 'utf8') : ''
-    })
+function scriptBodies(text) {
+  return [...stripCommentLines(text).matchAll(/\btasks\/[\w./-]+\.sh\b/g)]
+    .map((m) => join(REPO_ROOT, EQL_PACKAGE, m[0]))
+    .map((abs) => (existsSync(abs) ? readFileSync(abs, 'utf8') : ''))
     .join('\n')
 }
 
 /**
- * mise's task blocks, without a TOML parser.
+ * Every executable regular file under a directory, recursively and in a stable
+ * order.
  *
- * Adding one is an audit decision in this repo, and the shape needed here is
- * small: a `[tasks."<name>"]` header, an optional `depends = [...]`, and the
- * body text. `taskGraph` is guarded below on both the task count and a named
- * sample, so a format change empties nothing silently — it fails.
+ * The executable bit IS the inclusion rule — mise makes a file under an
+ * `includes` directory a task if and only if it can be executed, and this
+ * repository leans on that distinction deliberately. `tasks/build/ordering.sh`
+ * and `tasks/test/stub-fixtures.sh` are `source`d by other scripts rather than
+ * run, `tasks/test/{doc-anchors,sqlx-archive,sqlx-partition}.sh` are invoked as
+ * `bash tasks/...` from a TOML task, and `symbol_order_allowlist.txt`,
+ * `*.sql` and the two included `*.toml` are data. All nine are mode 644 and all
+ * nine are correctly excluded by this one rule — no extension allowlist, which
+ * would have to guess about `tasks/githooks/pre-commit` (no extension, a task)
+ * and `tasks/docs/generate/xml-to-json.py` (a `.py`, also a task).
+ *
+ * The mode is what git records (100755 vs 100644), so a CI checkout reproduces
+ * this exactly; it is not a property of one developer's umask.
+ */
+function executableFilesUnder(absDir) {
+  return readdirSync(absDir, { withFileTypes: true })
+    .sort((a, b) => (a.name < b.name ? -1 : 1))
+    .flatMap((entry) => {
+      const abs = join(absDir, entry.name)
+      if (entry.isDirectory()) return executableFilesUnder(abs)
+      if (!entry.isFile()) return []
+      // The POSIX mode is a bitfield; `& 0o111` is "executable by anyone".
+      return (statSync(abs).mode & 0o111) !== 0 ? [abs] : []
+    })
+}
+
+/**
+ * The task name mise derives from a file's path under an `includes` directory:
+ * directory separators become `:`, and the last extension is dropped —
+ * `tasks/test/bench.sh` is `test:bench`, `tasks/githooks/pre-commit` is
+ * `githooks:pre-commit`, `tasks/release/prepare-bindings-assets.test.sh` is
+ * `release:prepare-bindings-assets.test` (only the LAST extension goes).
+ *
+ * The exception is a collision. `tasks/test/known-failures.sh` would be
+ * `test:known-failures`, which `mise.toml` already defines; mise keeps the
+ * extension and calls the file task `test:known-failures.sh` instead. Modelling
+ * that matters here — collapse the two and the file task overwrites the TOML
+ * one, taking its `depends` and its body with it, and `test:known-failures`
+ * (which test-eql.yml really does run) stops resolving to the task CI runs.
+ *
+ * All three rules were checked against `mise tasks ls --hidden --json` on this
+ * tree: 73 tasks, and this derivation reproduces all 73 names exactly.
+ */
+function fileTaskName(relPath, isTaken) {
+  const segments = relPath.split(sep).join('/').split('/')
+  const base = segments.pop()
+  const stem = [...segments, base.replace(/\.[^.]+$/, '')].join(':')
+  return isTaken(stem) ? [...segments, base].join(':') : stem
+}
+
+/**
+ * The whole task graph, plus which config each task came from.
+ *
+ * `TASK_SOURCES` is not bookkeeping — it is the guard that would have caught
+ * the original defect. Two of the three configs contributed zero tasks and no
+ * assertion noticed, because the only floors were on the TOTAL.
  */
 function taskGraph() {
   const tasks = new Map()
-  for (const rel of MISE_CONFIGS) {
-    const text = readFileSync(join(REPO_ROOT, rel), 'utf8')
-    // Split on top-level table headers; keep the header with its body.
-    const blocks = text.split(/^(?=\[)/m)
-    for (const block of blocks) {
-      const header = /^\[tasks\.(?:"([^"]+)"|([\w:.-]+))\]/.exec(block)
-      if (!header) continue
-      const name = header[1] ?? header[2]
-      const depends = /^depends\s*=\s*\[([^\]]*)\]/m.exec(block)
-      tasks.set(name, {
-        file: rel,
-        body: block + scriptBodies(block),
-        depends: depends
-          ? [...depends[1].matchAll(/"([^"]+)"|'([^']+)'/g)].map(
-              (m) => m[1] ?? m[2],
-            )
-          : [],
-      })
+  const bySource = new Map()
+
+  const add = (source, name, body, depends) => {
+    tasks.set(name, { source, body: body + scriptBodies(body), depends })
+    bySource.get(source).push(name)
+  }
+
+  // mise.toml first, and the order is load-bearing: the file-task collision
+  // rule above asks whether a name is already taken.
+  const miseText = readRepo(MISE_TOML)
+  bySource.set(MISE_TOML, [])
+  for (const { name, block } of parseTomlTasks(miseText, {
+    bareTables: false,
+  })) {
+    add(MISE_TOML, name, block, parseDepends(block))
+  }
+
+  for (const include of parseIncludes(miseText)) {
+    const rel = `${EQL_PACKAGE}/${include}`
+    const abs = join(REPO_ROOT, rel)
+    // A missing include is not silently skipped: the empty source it leaves
+    // behind fails the per-config assertion below, which is the point.
+    const isDir = existsSync(abs) && statSync(abs).isDirectory()
+    const source = isDir ? `${rel}/**` : rel
+    bySource.set(source, bySource.get(source) ?? [])
+    if (!existsSync(abs)) continue
+
+    if (isDir) {
+      for (const fileAbs of executableFilesUnder(abs)) {
+        const body = readFileSync(fileAbs, 'utf8')
+        const name = fileTaskName(relative(abs, fileAbs), (n) => tasks.has(n))
+        add(source, name, body, parseDepends(body))
+      }
+    } else {
+      const text = readRepo(rel)
+      for (const { name, block } of parseTomlTasks(text, {
+        bareTables: true,
+      })) {
+        add(source, name, block, parseDepends(block))
+      }
     }
   }
-  return tasks
+
+  return { tasks, bySource }
 }
 
-const TASKS = taskGraph()
+const { tasks: TASKS, bySource: TASK_SOURCES } = taskGraph()
+const INCLUDES = parseIncludes(readRepo(MISE_TOML))
 
-/** Tasks whose body shells out to cargo. */
+/**
+ * Tasks whose body shells out to cargo.
+ *
+ * Deliberately matched against the RAW body, comments included. Over-matching
+ * costs one exemption with a reason; under-matching drops a real cargo check
+ * out of the set this file exists to police, and nothing downstream would say
+ * so.
+ */
 const CARGO_TASKS = [...TASKS]
   .filter(([, task]) => /(^|[^\w-])cargo(\s|$)/m.test(task.body))
   .map(([name]) => name)
   .sort()
 
 /**
- * Whether a workflow's executable part invokes a task BY NAME.
+ * The positions a real command can start at: the beginning of a line, after a
+ * shell separator, or after a YAML `run:` key. See `invokes`.
+ */
+const COMMAND_START = String.raw`(?:^|&&|\|\||[;|(){}]|(?<![\w:.-])run:)[ \t]*`
+
+/**
+ * Whether a body invokes a task BY NAME — as a command, not as prose.
+ *
+ * Three things are load-bearing here, and each was learned from a wrong answer
+ * this scan gave:
  *
- * The trailing guard is what makes `test:sqlx` distinct from
- * `test:sqlx:archive`: a plain substring search would mark the former reached
- * by any mention of the latter, and `test:sqlx` is precisely one of the tasks
- * that is NOT in CI (the archive/partition split replaced it). Getting that
- * wrong turns the exemption list below into a list of tasks that appear to run.
+ *   * The trailing `(?![\w:.-])` guard is what makes `test:sqlx` distinct from
+ *     `test:sqlx:archive`. A plain substring search marks the former reached by
+ *     any mention of the latter, and `test:sqlx` is precisely one of the tasks
+ *     that is NOT in CI (the archive/partition split replaced it). Getting that
+ *     wrong turns the exemption list below into a list of tasks that appear to
+ *     run.
+ *
+ *   * Comment lines are stripped, and `COMMAND_START` requires the invocation
+ *     to begin a command. Task bodies here are heavily commented and full of
+ *     `echo "… run 'mise run build' first"` diagnostics: of the 56 times the
+ *     string `mise run` appears across mise.toml and `tasks/**`, only 20 are a
+ *     command. Counting the other 36 creates FALSE reachability, which is the
+ *     one direction that matters — `test:sqlx`'s exemption went stale off a
+ *     single comment in `tasks/fixtures.toml` reading "regenerated on every
+ *     `mise run test:sqlx`".
+ *
+ *   * The gap between `mise run` and the name may not contain a quote
+ *     (`[^\n'"]*?`), only flags like `--output prefix`. Without it a real
+ *     invocation at the start of a line lends its command position to every
+ *     task named later on the SAME line, including inside a trailing quoted
+ *     `echo` — the shape `macro-expand-eql.yml` uses one line further down.
+ *
+ * The residual imprecision is one-directional by construction: a missed edge
+ * shows up as an orphan that has to be justified, which is loud.
  */
+const invocationPatterns = new Map()
 function invokes(body, taskName) {
-  const escaped = taskName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return new RegExp(
-    `mise\\s+run\\s+[^\\n]*?(?<![\\w:.-])${escaped}(?![\\w:.-])`,
-  ).test(body)
+  let pattern = invocationPatterns.get(taskName)
+  if (pattern === undefined) {
+    const escaped = taskName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    pattern = new RegExp(
+      `${COMMAND_START}mise\\s+run\\s+[^\\n'"]*?(?<![\\w:.-])${escaped}(?![\\w:.-])`,
+      'm',
+    )
+    invocationPatterns.set(taskName, pattern)
+  }
+  return pattern.test(stripCommentLines(body))
 }
 
-/** Task names any root workflow runs, closed over `depends`. */
-function reachableFromCi() {
+/**
+ * Every task→task edge, computed once.
+ *
+ * `depends` alone is not the graph. mise tasks routinely invoke other tasks
+ * from their `run =` body — `test:sqlx:prep` ends with `mise run
+ * fixture:generate:all`, `test:bench` opens with `mise run test:sqlx:prep`,
+ * `docs:validate:source` is three `mise run` lines and nothing else. Follow
+ * only `depends` and `fixture:generate:all` (which encrypts every SQLx fixture
+ * through ZeroKMS) reads as a task no workflow reaches.
+ *
+ * Computed here rather than inside `reachableFrom` because it does not depend
+ * on which workflows are in play, and the mutation test below runs that walk
+ * once per workflow.
+ */
+for (const [name, task] of TASKS) {
+  task.calls = new Set([
+    ...task.depends,
+    ...[...TASKS.keys()].filter(
+      (other) => other !== name && invokes(task.body, other),
+    ),
+  ])
+}
+
+/**
+ * Task names the given workflows run, closed over both edge kinds.
+ *
+ * The workflow list is a PARAMETER, not a read of the directory, so the
+ * mutation test at the bottom can delete a workflow without deleting a file.
+ */
+function reachableFrom(tasks, workflows) {
   const seen = new Set()
-  const queue = [...TASKS.keys()].filter((name) =>
-    rootWorkflows.some(({ body }) => invokes(body, name)),
+  const queue = [...tasks.keys()].filter((name) =>
+    workflows.some(({ body }) => invokes(body, name)),
   )
   while (queue.length > 0) {
     const name = queue.pop()
     if (seen.has(name)) continue
     seen.add(name)
-    queue.push(...(TASKS.get(name)?.depends ?? []))
+    queue.push(...(tasks.get(name)?.calls ?? []))
   }
   return seen
 }
 
 /**
- * Cargo tasks no workflow runs, each with the reason. Every entry is either a
- * developer convenience or the WRITE half of a regenerate-and-diff pair whose
- * READ half is in CI — never "we decided not to check this".
+ * Cargo tasks no workflow runs, each with the reason. Every entry is one of:
+ *
+ *   (a) a developer convenience — a watcher, an unsharded local run;
+ *   (b) the WRITE half of a regenerate-and-diff pair whose READ half is in CI;
+ *   (c) a second mise NAME for work CI already does under another name;
+ *   (d) blocked on a workflow that has not been ported yet, tracked in
+ *       UNPORTED_DEPOSIT at the bottom of this file.
+ *
+ * Never "we decided not to check this". An entry that stops describing an
+ * unreached cargo task fails the staleness check below, in both directions — so
+ * (d) in particular expires by itself the day its workflow is ported.
  */
 const CI_EXEMPT_CARGO_TASKS = new Map([
   [
@@ -318,33 +594,145 @@ const CI_EXEMPT_CARGO_TASKS = new Map([
     'test:codegen',
     "The generator's own unit tests, which `test:crates` already runs as part of the workspace. CI runs the stronger check: `codegen:parity` regenerates and diffs against the golden output.",
   ],
+  [
+    'codegen-parity',
+    'A second mise NAME for `tasks/codegen-parity.sh`: the script is executable and sits under an `includes` directory, so mise exposes it as a file task in addition to the `[tasks."codegen:parity"]` block that runs `bash tasks/codegen-parity.sh`. CI runs that block, in test-eql.yml `codegen`. Same script, same check, one name.',
+  ],
+  [
+    'schemas-parity',
+    'The same duplicate-name case as `codegen-parity`, for `tasks/schemas-parity.sh`. CI runs it as `test:schemas:parity`, in test-eql.yml `codegen`.',
+  ],
+  [
+    'test:lint',
+    '`cargo fmt --check` scoped to tests/sqlx. `test:crates` runs `cargo fmt --check` at the EQL workspace ROOT, and tests/sqlx is a workspace member, so the CI run covers exactly these files and four crates more — verified against `cargo fmt --check -v`, which lists packages/eql/tests/sqlx/** among its targets. test-eql.yml says the same thing at the `rust-crates` job, which is where the standalone lint step used to be.',
+  ],
+  [
+    'docs:generate:json',
+    'Generates docs/api/json/eql-manifest.json for the release docs bundle. Its only caller is `packages/eql/.github/workflows/_build-docs.yml` — one of the four unported RELEASE workflows in UNPORTED_DEPOSIT — so this is category (d): it becomes reachable the day that file is ported, and this entry then goes stale and must be deleted. It is also not portable as-is, since it falls back to `mise run docs:generate`, which needs a doxygen binary no job installs. Its cargo step (`cargo run -p eql-codegen dump-catalog`) is separately exercised in CI by `test:matrix:catalog-coverage`.',
+  ],
 ])
 
-describe('every cargo check EQL owns is reached by a root workflow', () => {
-  const reachable = reachableFromCi()
-
-  it('parses the mise task graph', () => {
-    // The guard on the scan. A `[tasks."x"]` spelling change, or a config file
-    // moving, would empty `TASKS` — and every check below would then pass
-    // having examined nothing.
-    expect(TASKS.size).toBeGreaterThanOrEqual(30)
-    expect([...TASKS.keys()]).toContain('test:sqlx:archive')
+/** Cargo tasks a given reachability set leaves unaccounted for. */
+const orphanCargoTasks = (reachable) =>
+  CARGO_TASKS.filter(
+    (name) => !reachable.has(name) && !CI_EXEMPT_CARGO_TASKS.has(name),
+  )
+
+describe('the scan sees every task mise sees', () => {
+  it('reads the include list out of mise.toml', () => {
+    // If this parse fails, every included config below disappears at once and
+    // the per-source check has nothing left to find empty.
+    expect(
+      INCLUDES,
+      `Could not read \`[task_config].includes\` from ${MISE_TOML}. Everything mise loads beyond mise.toml itself is named there, so an unparsed list means this whole scan reads one file and reports success.`,
+    ).toContain('tasks')
+  })
+
+  it('draws at least one task from every config, and from the file walk', () => {
+    // THE property whose absence made the original defect invisible.
+    // `tasks/postgres.toml` and `tasks/fixtures.toml` contributed zero tasks
+    // for the life of the old scan — it looked only for `[tasks."x"]`, and
+    // those files use the bare-table form — while `TASKS.size >= 30` passed on
+    // mise.toml's 32 blocks alone. A floor on the total cannot see a config
+    // that goes quiet; a floor per config is the only shape that can.
+    const empty = [...TASK_SOURCES]
+      .filter(([, names]) => names.length === 0)
+      .map(([source]) => source)
+
+    expect(
+      empty,
+      `These task configs contributed no tasks at all. Either the file moved, or its table syntax is a shape the parser does not know. A config contributing zero is indistinguishable from a config full of tasks that all pass:\n${empty
+        .map((s) => `  ${s}`)
+        .join('\n')}`,
+    ).toEqual([])
+
+    // One source per `includes` entry, plus mise.toml itself. Catches an entry
+    // that resolved to nothing at all rather than to an empty file.
+    expect(TASK_SOURCES.size).toBe(INCLUDES.length + 1)
+  })
+
+  it('names a task from each source, so a source cannot be full of nonsense', () => {
+    // Non-emptiness would be satisfied by a parser that read table headers as
+    // gibberish. These four pin one real name per source.
+    const from = (source) => TASK_SOURCES.get(source) ?? []
+    expect(from(MISE_TOML)).toContain('test:sqlx:archive')
+    expect(from(`${EQL_PACKAGE}/tasks/postgres.toml`)).toContain('postgres:up')
+    expect(from(`${EQL_PACKAGE}/tasks/fixtures.toml`)).toContain(
+      'fixture:generate:all',
+    )
+    expect(from(`${EQL_PACKAGE}/tasks/**`)).toContain('test:bench')
+  })
+
+  it('derives file-task names the way mise does', () => {
+    const names = [...TASKS.keys()]
+    // Extension dropped, directories joined with `:`.
+    expect(names).toContain('test:bench')
+    // No extension at all, and not under `tasks/test`.
+    expect(names).toContain('githooks:pre-commit')
+    // Only the LAST extension goes.
+    expect(names).toContain('release:prepare-bindings-assets.test')
+    // The collision case: `tasks/test/known-failures.sh` keeps its extension
+    // because `[tasks."test:known-failures"]` in mise.toml claimed the stem.
+    // Collapse these two and the file task silently replaces the TOML one, and
+    // `test:known-failures` — which test-eql.yml runs — resolves to a task with
+    // different content.
+    expect(names).toContain('test:known-failures.sh')
+    expect(TASKS.get('test:known-failures')?.source).toBe(MISE_TOML)
+  })
+
+  it('leaves non-executable files out of the task set', () => {
+    // The inclusion rule is the executable bit, nothing else. These four are
+    // mode 644 and are NOT tasks: two are `source`d by other scripts, one is
+    // invoked as `bash tasks/...` from a TOML task, one is data. A rule based
+    // on the `.sh` extension would wrongly promote all three scripts, and an
+    // allowlist of extensions would wrongly demote `githooks:pre-commit`.
+    const names = [...TASKS.keys()]
+    expect(names).not.toContain('build:ordering') // sourced by tasks/build.sh
+    expect(names).not.toContain('test:stub-fixtures') // sourced by 5 tasks
+    expect(names).not.toContain('test:sqlx-archive') // `bash tasks/...`
+    expect(names).not.toContain('test:symbol_order_allowlist') // a .txt
+  })
+
+  it('reads `depends` from both dialects', () => {
+    // TOML form.
     expect(TASKS.get('test:sqlx')?.depends).toEqual(['test:sqlx:prep'])
+    // `#MISE depends=[...]` header-comment form, which only file tasks use. Without
+    // it `docs:validate:source` — which test-eql.yml runs on every PR — stops
+    // being a caller of `build`.
+    expect(TASKS.get('docs:validate:source')?.depends).toEqual(['build'])
   })
 
-  it('finds the tasks that invoke cargo, including through a script', () => {
-    // 19 today. The floor is set above the 15 that block-only parsing finds, so
-    // losing `scriptBodies` fails here rather than silently shrinking the set
-    // by the four tasks most worth checking.
-    expect(CARGO_TASKS.length).toBeGreaterThanOrEqual(18)
+  it('parses the whole graph, not a fragment of it', () => {
+    // 73 today, matching `mise tasks ls --hidden --json` name for name. A
+    // coarse net under the per-source checks above: it catches a shrinkage
+    // that leaves every source non-empty.
+    expect(TASKS.size).toBeGreaterThanOrEqual(70)
+  })
+})
+
+describe('every cargo check EQL owns is reached by a root workflow', () => {
+  const reachable = reachableFrom(TASKS, rootWorkflows)
 
-    // The named case: `run = "bash tasks/test/sqlx-archive.sh"`. Nothing in the
-    // task block mentions cargo; `cargo nextest archive` is in the script.
+  it('finds the tasks that invoke cargo, including through a script', () => {
+    // 26 today. The floor sits above the 19 a mise.toml-only scan finds, so
+    // losing the file walk or an included config fails here rather than
+    // silently shrinking the set by the seven tasks it took to notice they
+    // were missing.
+    expect(CARGO_TASKS.length).toBeGreaterThanOrEqual(24)
+
+    // One named case per parsing class, because the count alone cannot say
+    // WHICH class went missing:
+    // a TOML task whose cargo lives in a delegated script,
     expect(CARGO_TASKS).toContain('test:sqlx:archive')
+    // a FILE task (tasks/test/bench.sh — the class that made deleting
+    // bench-eql.yml invisible),
+    expect(CARGO_TASKS).toContain('test:bench')
+    // and a bare-table task in an included config.
+    expect(CARGO_TASKS).toContain('fixture:generate:all')
   })
 
   it('distinguishes a task name from a longer task that starts with it', () => {
-    // The property `invokes` exists for. Without the trailing guard,
+    // The property the trailing guard in `invokes` exists for. Without it,
     // `test:sqlx` reads as reached by test-eql.yml's archive and partition
     // steps, and drops out of the exemption list silently.
     const body = 'run: mise run test:sqlx:archive\nrun: mise run test:schema\n'
@@ -353,13 +741,67 @@ describe('every cargo check EQL owns is reached by a root workflow', () => {
     expect(invokes(body, 'test:schema')).toBe(true)
   })
 
-  it('runs every cargo task, or names it as exempt with a reason', () => {
-    const orphans = CARGO_TASKS.filter(
-      (name) => !reachable.has(name) && !CI_EXEMPT_CARGO_TASKS.has(name),
+  it('counts a command and not a mention of one', () => {
+    // Every form below is real text from this tree. The three that must NOT
+    // count are the ones that made `test:sqlx` look reached.
+    expect(invokes('  mise run test:sqlx:prep\n', 'test:sqlx:prep')).toBe(true)
+    expect(invokes('mise run clean && mise run build\n', 'build')).toBe(true)
+    expect(invokes('        run: mise run test:crates\n', 'test:crates')).toBe(
+      true,
     )
+    expect(
+      invokes(
+        'mise run --output prefix test:bench --postgres 17\n',
+        'test:bench',
+      ),
+    ).toBe(true)
+
+    // A comment (tasks/fixtures.toml, on the fixture regeneration cadence).
+    expect(
+      invokes('# regenerated on every `mise run test:sqlx`\n', 'test:sqlx'),
+    ).toBe(false)
+    // Comment stripping is a SECOND line of defence, not a redundant one, and
+    // this case is what separates the two: the sentence puts `mise run` right
+    // after a `;`, which is a position COMMAND_START accepts. mise.toml is full
+    // of prose in this shape ("only WRITES the snapshots; `mise run
+    // test:matrix:inventory` is the gate"), and today every instance happens to
+    // carry a backtick that COMMAND_START rejects — an accident, not a rule.
+    expect(
+      invokes(
+        '# writes them; mise run test:matrix:inventory is the gate\n',
+        'test:matrix:inventory',
+      ),
+    ).toBe(false)
+    // A diagnostic (tasks/codegen-parity.sh).
+    expect(
+      invokes(
+        `echo "surface is stale — run 'mise run build' and commit"\n`,
+        'build',
+      ),
+    ).toBe(false)
+    // A real invocation and a quoted mention on ONE line (macro-expand-eql.yml
+    // shape). The first must count and the second must not.
+    const mixed = `mise run test:schema || { echo "run 'mise run test:sqlx' first"; }\n`
+    expect(invokes(mixed, 'test:schema')).toBe(true)
+    expect(invokes(mixed, 'test:sqlx')).toBe(false)
+  })
+
+  it('follows `mise run` inside a task body, not only `depends`', () => {
+    // `test:sqlx:prep` ends with `mise run fixture:generate:all`, and nothing
+    // declares that as a dependency. Under a depends-only closure the task that
+    // mints every SQLx fixture through ZeroKMS reads as unreached — an orphan
+    // that no workflow could ever clear, since no workflow names it.
+    expect(TASKS.get('test:sqlx:prep')?.depends).not.toContain(
+      'fixture:generate:all',
+    )
+    expect([...reachable]).toContain('fixture:generate:all')
+  })
+
+  it('runs every cargo task, or names it as exempt with a reason', () => {
+    const orphans = orphanCargoTasks(reachable)
     expect(
       orphans,
-      `These mise tasks invoke cargo and no workflow in ${WORKFLOW_DIR} reaches them, directly or through \`depends\`. A check nothing invokes reads exactly like a check that passes. Either add it to a workflow, or add it to CI_EXEMPT_CARGO_TASKS with the reason it does not belong in CI:\n${orphans
+      `These mise tasks invoke cargo and no workflow in ${WORKFLOW_DIR} reaches them, directly, through \`depends\`, or through a \`mise run\` in a task body. A check nothing invokes reads exactly like a check that passes. Either add it to a workflow, or add it to CI_EXEMPT_CARGO_TASKS with the reason it does not belong in CI:\n${orphans
         .map((name) => `  ${name}`)
         .join('\n')}`,
     ).toEqual([])
@@ -368,7 +810,8 @@ describe('every cargo check EQL owns is reached by a root workflow', () => {
   it('keeps no exemption for a task that is run, or has gone', () => {
     // Both directions. An exemption for a task CI now runs is noise that hides
     // the next one; an exemption for a task that no longer exists is a claim
-    // about nothing.
+    // about nothing. This is also what retires the `docs:generate:json` entry
+    // automatically once `_build-docs.yml` is ported to the repository root.
     const stale = [...CI_EXEMPT_CARGO_TASKS.keys()].filter(
       (name) => !TASKS.has(name) || reachable.has(name),
     )
@@ -379,6 +822,72 @@ describe('every cargo check EQL owns is reached by a root workflow', () => {
   })
 })
 
+/**
+ * Workflows that are the SOLE caller of some cargo check.
+ *
+ * Deleting one of these silently removes coverage, which is the failure this
+ * whole file is about — so the list is written down, and the tests below drive
+ * the scan against a workflow set with each one removed to prove the guard
+ * actually fails.
+ */
+const SOLE_CALLER_WORKFLOWS = [
+  `${WORKFLOW_DIR}/bench-eql.yml`, // test:bench
+  `${WORKFLOW_DIR}/macro-expand-eql.yml`, // test:matrix:expand
+  `${WORKFLOW_DIR}/test-eql.yml`, // most of the suite
+]
+
+describe('the guard fails when a workflow stops calling a cargo check', () => {
+  /**
+   * The mutation is injected, not performed. Deleting `bench-eql.yml` from the
+   * working tree and re-running is what proved the ORIGINAL scan blind — all 14
+   * assertions stayed green, because `test:bench` is a FILE task and file tasks
+   * were not parsed at all. Encoding that as a permanent test means passing a
+   * shorter workflow list to `reachableFrom`, which is the reason that function
+   * takes one rather than reading the directory. `lint-no-eql-registry-pins.mjs`
+   * splits `lint()` from `report()` for the same reason.
+   */
+  const without = (relPath) =>
+    rootWorkflows.filter((wf) => wf.relPath !== relPath)
+
+  it('reports test:bench as an orphan when bench-eql.yml goes', () => {
+    const workflows = without(BENCH_WORKFLOW)
+    // The mutation has to actually remove something, or this proves nothing.
+    expect(workflows.length).toBe(rootWorkflows.length - 1)
+
+    const orphans = orphanCargoTasks(reachableFrom(TASKS, workflows))
+    expect(
+      orphans,
+      `Removing ${BENCH_WORKFLOW} left every cargo check accounted for, which means this file would not notice its deletion. \`test:bench\` (packages/eql/tasks/test/bench.sh, the cargo \`bench\`-feature SQLx suite) has no other caller, so it must be reported. If the bench suite genuinely moved to another workflow, update SOLE_CALLER_WORKFLOWS.`,
+    ).toContain('test:bench')
+  })
+
+  it('names every workflow whose deletion would orphan a cargo check', () => {
+    const soleCallers = rootWorkflows
+      .map(({ relPath }) => relPath)
+      .filter(
+        (relPath) =>
+          orphanCargoTasks(reachableFrom(TASKS, without(relPath))).length > 0,
+      )
+
+    expect(
+      soleCallers,
+      `The set of workflows carrying EQL's only copy of some cargo check has changed.\n` +
+        'GREW: a check that had a second caller now has one — expected if a job moved, but it means that file is now load-bearing.\n' +
+        "SHRANK: a workflow stopped being anyone's only caller. Either its checks moved elsewhere (fine, update this list) or it stopped running them (not fine).\n" +
+        'A workflow dropping out because its checks now run NOWHERE cannot happen quietly — the orphan check above fails first.',
+    ).toEqual(SOLE_CALLER_WORKFLOWS)
+  })
+
+  it('is not vacuous: some workflow is load-bearing', () => {
+    // If every cargo check had two callers this whole describe block would pass
+    // by finding nothing, and so would a scan that parsed no tasks at all.
+    expect(SOLE_CALLER_WORKFLOWS.length).toBeGreaterThan(0)
+    expect(CARGO_TASKS.length).toBeGreaterThan(
+      CI_EXEMPT_CARGO_TASKS.size, // more cargo tasks run than are excused
+    )
+  })
+})
+
 /**
  * What is still allowed to sit in the deposited `.github`, and why.
  *
@@ -403,7 +912,7 @@ const UNPORTED_DEPOSIT = [
   // until trusted publishing is repointed at cipherstash/stack.
   '.github/release.yml', // release-notes categorisation config, not a workflow
   '.github/workflows/README.md', // documents the four below
-  '.github/workflows/_build-docs.yml',
+  '.github/workflows/_build-docs.yml', // the sole caller of `docs:generate:json`
   '.github/workflows/_build-sql.yml',
   '.github/workflows/lint-release.yml', // actionlints the four below
   '.github/workflows/rebuild-docs.yml',

From 3b38d885ce3f2fb21345f66f86a0ff35633aa33b Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:26:44 +1000
Subject: [PATCH 12/20] fix(eql): close three holes in the registry-pin linter,
 and record the subtree
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

THE LINTER NEVER OPENED pnpm-workspace.yaml. It walked every Cargo.toml and
package.json, which is where a pin is DECLARED — but pnpm resolves
`overrides` and `catalogs` from the workspace file, and that file's own
comment says so. An override there moves what actually installs while every
`workspace:^` in the tree still reads correct, which is the quietest
possible way to reintroduce the skew between the Rust that emits an EQL
payload and the SQL that stores one. It now reads `overrides`, `catalog`
and `catalogs.<name>`, recurses into nested npm overrides, and matches
selector keys (`@cipherstash/eql@<3.0.5`, `pkg>@cipherstash/eql`, yarn's
`**/` globs) and aliased values (`npm:@cipherstash/eql@3.0.4`).

Two judgements worth recording. A `catalog:` specifier in a manifest stays
an OFFENDER — unlike Cargo's `workspace = true`, a catalog holds version
ranges, so there is no in-tree answer to defer to and both ends are
flagged. And YAML scalars are coerced rather than dropped, because
`'@cipherstash/eql': 3.0` parses as the NUMBER 3 under YAML 1.1 — dropping
non-strings would drop exactly that pin.

`EXPECTED_SOURCES` is the floor the workspace file needs: it declares
nothing today, so the only checkable antecedent is that it was opened and
parsed. Exit 2 for a source that is missing, unparseable or emptied out,
checked before offenders, on the existing contract.

AGENTS.md rule 7 was not followed by the absorption itself: this adds the
largest package in the repo and neither meta file mentioned it. Adds the
Repository Layout entry and a "Working on EQL" section covering the seams
where failures are silent — the two-level package path and why root `pnpm
test` needs `./packages/**`, `working_directory: packages/eql` for mise
(and EQL_ROOT, since `git rev-parse --show-toplevel` now answers the
monorepo root), the dead `.github/` deposit, the lockstep version identity
and the `mise run build --version` cache-key trap, the path dep and its
linter, the CI-workspace-keyed SteVec constants, and publishing not having
moved. Corrects two now-false claims in the protect-ffi section, including
"the only Rust in this repo".

The plan's Phase-5 item for a `lint-no-eql-changeset.mjs` is marked
superseded: `FROZEN_PUBLISHERS` in release-gate.mjs is strictly stronger,
catching the hand-applied bump that no changeset-side guard could see. It
also records that `.changeset/rename-ste-vec-contains.md.deferred` must NOT
be restored — it was deleted deliberately in 9b1c44d9 so the cutover cannot
apply the same bump twice, and re-parking that `major` changeset would bump
an already-released 3.0.5 to 4.0.0.
---
 AGENTS.md                                     | 129 ++++++-
 SECURITY.md                                   |  12 +
 .../2026-08-13-eql-monorepo-absorption.md     |   2 +-
 .../lint-no-eql-registry-pins.test.mjs        | 322 ++++++++++++++++++
 scripts/lint-no-eql-registry-pins.mjs         | 318 +++++++++++++++--
 5 files changed, 748 insertions(+), 35 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index da9f95f20..59923b409 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -83,6 +83,7 @@ If these variables are missing, tests that require live encryption will fail or
 - `packages/utils`: Shared config (`utils/config`) and logger (`utils/logger`)
 - `packages/bench`: Performance / index-engagement benchmarks (private, not published)
 - `packages/protect-ffi`: Native FFI bindings to the CipherStash Client SDK (`@cipherstash/protect-ffi`) — the Rust core that `packages/stack` encrypts and decrypts through, absorbed from `cipherstash/protectjs-ffi`. Contains a **nested Cargo workspace** (`crates/`) and six per-platform binary packages under `platforms/*`, each published as `@cipherstash/protect-ffi-<platform>` and linked here via `workspace:*`. See the "Working on protect-ffi" notes below before touching it — its default `test` and `build` are deliberately Rust-free.
+- `packages/eql`: The Encrypt Query Language subtree — the SQL bundle that stores and queries encrypted payloads — absorbed from `cipherstash/encrypt-query-language`. **The directory is the subtree root, not the package.** It was imported at a *verbatim prefix* so its repo-root-relative paths (mise tasks, `Doxyfile`, `sync-generated.mjs`) keep resolving, which puts the npm package `@cipherstash/eql` two levels down at `packages/eql/packages/eql` — the same shape as `packages/protect-ffi/platforms/*`, and enrolled the same way, by an explicit `packages/eql/packages/*` glob in `pnpm-workspace.yaml`. The subtree root deliberately carries no `package.json`. Also contains a **nested Cargo workspace** at `packages/eql/crates/` (`eql-bindings`, published in lockstep with the npm package, plus `eql-domains` / `eql-codegen` / `eql-tests-macros`, which are not), a SQLx test crate at `packages/eql/tests/sqlx`, an ~900-line `mise.toml` task surface, its own `AGENTS.md`, and `docs/`. See the "Working on EQL" notes below before touching it.
 - `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).
@@ -90,11 +91,12 @@ If these variables are missing, tests that require live encryption will fail or
 
 ## Working on protect-ffi
 
-`packages/protect-ffi` is the only Rust in this repo, and its scripts are split
-so that stays true for everyone else.
+`packages/protect-ffi` carries one of this repo's two Cargo workspaces (the
+other is `packages/eql/crates`), and its scripts are split so a Rust toolchain
+stays optional for everyone else.
 
 - **The default `test` and `build` never invoke cargo.** Root `pnpm test` runs
-  `turbo test --filter './packages/*'`, which reaches this package — so a cargo
+  `turbo test --filter './packages/**'`, which reaches this package — so a cargo
   process on that path is a Rust toolchain on every contributor's machine.
   `test` is the JS chain; `build` is `tsc`.
 - **CI does build the binding, in the jobs that need it.** That is the limit of
@@ -214,6 +216,127 @@ EQL versions installed** in the database.
   what stops it going quiet again, and it deliberately scans only the repo-root
   workflow directory.
 
+## Working on EQL
+
+`packages/eql` is a subtree import, not a package directory, and almost
+everything surprising about it follows from that. Its own `AGENTS.md`
+(`packages/eql/AGENTS.md`) covers EQL-internal work — SQL authoring, the codegen
+pipeline, documentation standards. The notes below cover the *seams* with this
+monorepo, which is where the silent failures are.
+
+- **The package is at `packages/eql/packages/eql`, two levels down.** The
+  subtree root has no `package.json` by design, so a tool that globs one level
+  under `packages/` selects the root — a directory with no manifest and no
+  scripts — and not the package. That is why root `pnpm test` is
+  `turbo test --filter './packages/**'` and not `'./packages/*'`: under the
+  one-level filter the task graph contained `@cipherstash/eql#build` (pulled in
+  transitively by its consumers) and **no `#test` at all**, so its Vitest suite
+  ran nowhere while CI stayed green. `build` can stay one-level because
+  consumers pull it through `^build`. Anything else that walks `packages/*` needs
+  the same treatment — `scripts/lint-typecheck-scope.mjs` already carries the
+  two nested roots explicitly.
+- **Anything invoking a mise task must run with `working_directory:
+  packages/eql`.** `packages/eql/mise.toml` is ~900 lines and its
+  `[task_config].includes` pulls in `tasks/`, `tasks/postgres.toml` and
+  `tasks/fixtures.toml`; task bodies address `tasks/…`, `release/…` and
+  `tests/sqlx/…` relative to the subtree root. mise reads config from the
+  current directory and its parents, so invoking from the repo root finds no EQL
+  config and fails with a *trust* error that reads like a broken toolchain
+  rather than a wrong directory. `[env]` also pins `EQL_ROOT = {{config_root}}`,
+  because two task scripts use `git rev-parse --show-toplevel`, which after the
+  import returns the **monorepo** root — and one of them,
+  `tasks/test/doc-anchors.sh`, fails silently when that is wrong.
+- **`packages/eql/.github/` is a dead deposit.** GitHub reads workflows from the
+  repo root and nowhere else, so the eleven files there run on nothing. Seven
+  are workflows — four publish something (`release.yml`, `release-plz.yml`,
+  `release-postgres-eql-image.yml`, `rebuild-docs.yml`) and three exist only to
+  serve them (two `workflow_call` reusables and `lint-release.yml`) — alongside
+  a `workflows/README.md`, the release-notes config, and two
+  repository-settings files. `scripts/__tests__/eql-suite-ci.test.mjs` holds
+  them as a **shrinking allowlist** (`UNPORTED_DEPOSIT`), asserted by equality so
+  it fails in both directions: porting a workflow means deleting it from the
+  deposit *and* from the list in the same commit, and dropping a new file in
+  there without listing it fails too. The same test asserts that the three SQLx
+  suite tasks are invoked by name from a root workflow, that every
+  `dorny/paths-filter` path is scoped to `packages/eql/`, and that every mise
+  task shelling out to cargo is either reachable from a root workflow or
+  exempted with a written reason. It is the guard against the failure this
+  absorption keeps rediscovering: a check that arrives as a file and executes on
+  no event reads exactly like a check that passes.
+- **One version, five artefacts.** `@cipherstash/eql` (npm), the `eql-bindings`
+  crate, the SQL bundle, the docs and the `postgres-eql` image all ship at a
+  single version V. The npm package's `version` is the source of truth
+  (`changeset version` owns it) and `scripts/sync-lockstep-versions.mjs`
+  propagates it to the crate and, via `mise run
+  release:prepare_bindings_assets`, to the stamped SQL and release manifests. It
+  runs from the root `version` script — Changesets only invokes the *root* one,
+  which is why the script lives at the repo root and derives the subtree path
+  itself. **`mise run build --version X` does not treat `--version` as a
+  cache-key input**: it is absent from `tasks/build.sh`'s `#MISE sources`, so on
+  unchanged SQL and Rust it is a cache hit that re-serves whatever version the
+  previous build stamped. `tasks/release/prepare-bindings-assets.sh` passes
+  `--force` for exactly that reason and then greps the stamp back out of the
+  SQL before writing a manifest over it — read its comment before touching that
+  path. Without both, the bundle ships stamped one version under a manifest,
+  crate and npm package claiming another, and every digest still verifies.
+- **`eql-bindings` resolves by path from `packages/protect-ffi`, never from
+  crates.io**, and `scripts/lint-no-eql-registry-pins.mjs` (`pnpm run
+  lint:eql-pins`) is what keeps it that way. The two halves of EQL are the Rust
+  that EMITS a payload and the SQL that STORES and queries one; a registry pin
+  lets them drift apart silently — it compiles, it passes CI, and it fails in a
+  database. The linter reads every `Cargo.toml` and `package.json` plus
+  `pnpm-workspace.yaml` (pnpm resolves `overrides` and `catalogs` from there,
+  and a top-level npm-format `overrides` block in a `package.json` is silently
+  ignored, so it is the one place a workspace-wide pin can be written and take
+  effect). It exits **2**, not 0, when its own configuration has gone stale —
+  a source it could not read, a declaration it expected and no longer sees, or
+  an exemption excusing nothing. There is one exemption today
+  (`packages/protect-ffi/integration-tests`, which installs with `npm ci` and
+  cannot take a `workspace:` specifier); adding another means writing the reason
+  down.
+- **Two SQLx test constants are keyed to this repo's CI workspace.** SteVec
+  selectors are MACs over (column context, JSONPath) under a *workspace keyset*,
+  so `SELECTOR` in `tests/sqlx/src/fixtures/v3_doc_integer.rs` and `SEL_HELLO_OP`
+  in `tests/sqlx/src/fixtures/v3_ste_vec.rs` changed value — with no change to
+  Rust, SQL or fixture logic — the moment CI moved to this repo's
+  `CS_WORKSPACE_CRN` (`9467cc5d`, `da141339`). Each has a drift guard that
+  prints the candidate selectors and their discriminators rather than inferring
+  a replacement, because guessing wrong re-pins to the wrong leaf silently —
+  which had already happened once, `SEL_HELLO_OP` naming `$.number` while
+  claiming `$.hello` and surviving because an equality-only assertion cannot
+  separate them. **If you run the suite against your own CipherStash workspace
+  the guards will fire: do not commit your local value.** Rotating
+  `CS_WORKSPACE_CRN` re-pins both. `tests/sqlx/src/selectors.rs` holds five more
+  workspace-keyed constants with no consumers and no guard — delete or guard
+  them before using any of them.
+- **Publishing has not moved yet.** npm trusted publishing for `@cipherstash/eql`
+  still names `cipherstash/encrypt-query-language` — the SLSA provenance on
+  `@cipherstash/eql@3.0.4` records that repository and
+  `.github/workflows/release.yml` — and the package's own `repository` / `bugs`
+  fields still point there, as do the `eql-bindings` crate's. Repointing all of
+  it is the Phase-5 cutover, together with the nine parked workflows above.
+  This is protect-ffi's situation with one difference: the guard is not a
+  changeset lint but `scripts/release-gate.mjs`, and it is the stronger of the
+  two. Its `FROZEN_PUBLISHERS` map lists every package that lives here but is
+  published from another repository, and the gate **exits non-zero** — failing
+  the `gate` job, which skips `release` entirely — if such a package's committed
+  version is missing from npm, or if any published package carries a runtime
+  `workspace:` range that only that package could satisfy. It fires today on the
+  hand-applied 3.0.5 bump, which a changeset-side guard could not see, and it
+  blocks the Version Packages PR as well as the publish. `tests.yml` runs the
+  same script at PR time so the answer arrives a merge earlier. Delete the
+  `@cipherstash/eql` entry in the Phase-5 cutover — and note the FFI half of
+  that map is what turns `lint-no-ffi-changeset.mjs`'s unstated assumption
+  ("all seven are already on npm at the workspace version") into a checked one.
+  Note too that 3.0.5 did *not* come from `changeset version` —
+  eleven unrelated changesets were pending, so the bump was entered by hand in
+  `packages/eql/packages/eql/CHANGELOG.md` and the parked
+  `rename-ste-vec-contains.md.deferred` deleted with it, precisely so the
+  cutover cannot apply the same bump twice. Read that CHANGELOG entry before
+  assuming a version's provenance.
+- **Changesets for `@cipherstash/eql` go in the repo-root `.changeset/`.**
+  `packages/eql/.changeset/` is an empty leftover of the subtree.
+
 ## Agent Skills — these ship to customers
 
 `skills/*/SKILL.md` are **published artifacts, not internal notes.** Treat a wrong
diff --git a/SECURITY.md b/SECURITY.md
index 7cde6b1bf..e4c960dab 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -19,6 +19,18 @@ This repository is the CipherStash Stack monorepo for JavaScript/TypeScript. It
 | `@cipherstash/wizard` | AI-powered encryption setup |
 | `@cipherstash/protect-ffi` | Native FFI bindings to the CipherStash Client SDK — the Rust core `@cipherstash/stack` encrypts and decrypts through |
 | `@cipherstash/protect-ffi-darwin-arm64`<br>`@cipherstash/protect-ffi-darwin-x64`<br>`@cipherstash/protect-ffi-linux-arm64-gnu`<br>`@cipherstash/protect-ffi-linux-x64-gnu`<br>`@cipherstash/protect-ffi-linux-x64-musl`<br>`@cipherstash/protect-ffi-win32-x64-msvc` | Prebuilt per-platform binaries for `@cipherstash/protect-ffi`. Installed as optional dependencies; one is selected at load time for the host platform |
+| `@cipherstash/eql` | Encrypt Query Language — the PostgreSQL SQL bundle (`eql_v3` schema: domains, operators, index-term extractors) that stores and queries encrypted payloads, plus its generated TypeScript types. Applied by `stash eql install` and by the Prisma Next adapter's migrations. Released in lockstep with the `eql-bindings` Rust crate, which emits the payloads this SQL reads |
+
+This repository also carries the source of the **`eql-bindings`** Rust crate
+(`packages/eql/crates/eql-bindings`), published to crates.io and released in
+lockstep with `@cipherstash/eql`. It is in scope for security reports on the
+same terms as the npm packages above.
+
+> **Note on publishing.** `@cipherstash/eql`, `eql-bindings`, and the seven
+> `@cipherstash/protect-ffi*` packages have been absorbed into this repository
+> but are still *published* from `cipherstash/encrypt-query-language` and
+> `cipherstash/protectjs-ffi` respectively, pending an npm trusted-publishing
+> cutover. Their source, issues, and security reports belong here.
 
 **Security fixes are released for the latest release line of each package.** Security reports are welcome for any version, but fixes land in the latest release — if you are running an older major version, plan to upgrade to receive them.
 
diff --git a/docs/plans/2026-08-13-eql-monorepo-absorption.md b/docs/plans/2026-08-13-eql-monorepo-absorption.md
index 2f2a7f4ea..4e87c4735 100644
--- a/docs/plans/2026-08-13-eql-monorepo-absorption.md
+++ b/docs/plans/2026-08-13-eql-monorepo-absorption.md
@@ -315,7 +315,7 @@ Five surfaces, each flipped independently, each inert until its own cutover.
 
 - [ ] **Carried over from Phase 4, deliberately.** Port `lint-release.yml` and the two reusable workflows (`_build-sql.yml`, `_build-docs.yml`) alongside the release workflows they gate and are called from — a lint aimed at four absent files is worse than no lint. Add `cache: false` to the three `jdx/mise-action` steps that omit it (`_build-sql.yml`, `_build-docs.yml`, `release-postgres-eql-image.yml`), and add those two plus `release-plz.yml` to `scripts/lint-no-workflow-caching.mjs`'s `TARGETS`, with their remote actions in `AUDITED_ACTIONS` — or the gate fails on the addition itself.
 - [ ] **Then delete `packages/eql/.github/` entirely**, and convert the shrinking allowlist in `scripts/__tests__/eql-suite-ci.test.mjs` to a straight `existsSync(...) === false`, alongside the existing protect-ffi assertion in `lintWiring.test.ts`. The allowlist is an equality, so it will already be failing by the time the last file goes — that is what makes this step forced rather than remembered.
-- [ ] Add `scripts/lint-no-eql-changeset.mjs` in the shape of the FFI guard, so an `@cipherstash/eql` changeset parks as `.changeset/<name>.md.deferred` until npm publishing actually moves. Carry the pending `rename-ste-vec-contains.md` in parked form.
+- [x] ~~Add `scripts/lint-no-eql-changeset.mjs` in the shape of the FFI guard~~ — **superseded, and do not restore the parked changeset.** The guard landed instead as `FROZEN_PUBLISHERS` in `scripts/release-gate.mjs`, which is strictly stronger: it exits non-zero on any frozen package whose committed version is missing from npm *and* on any runtime `workspace:` range only that package could satisfy, so it catches the hand-applied 3.0.5 bump that no changeset-side guard could see. It runs at PR time via `tests.yml` and at release time via `release.yml`. `.changeset/rename-ste-vec-contains.md.deferred` was deleted deliberately in `9b1c44d9` — the 3.0.5 bump was entered by hand in the CHANGELOG, so re-parking that `major` changeset would make the cutover bump the package a second time (3.0.5 → 4.0.0) for a rename already released. **Phase-5 action: delete the `@cipherstash/eql` entry from `FROZEN_PUBLISHERS`, nothing more.**
 - [ ] Repoint all EQL manifests at `cipherstash/stack`: `packages/eql/packages/eql/package.json` — `repository.url`, `repository.directory` → `packages/eql/packages/eql`, **and `bugs.url`** (line 13, still `encrypt-query-language/issues`, which would send users to an archived repo) — plus `crates/eql-bindings/Cargo.toml` (`repository`, `homepage`) and `release-plz.toml`'s prose. npm and crates.io both reject a publish whose repository field does not match; `bugs.url` is not enforced, which is why it is the one that survives a cutover unnoticed.
 - [ ] Port `release.yml`'s EQL half into this repo's `release.yml` — the existing gate-then-publish structure already models "one version authority plus N idempotent publishers", which is the shape it was derived from. Preserve the `classify` prerelease path and the `eql-typescript-v<version>` idempotency short-circuit.
 - [ ] Port `release-plz.yml` unchanged in filename — crates.io trusted publishing binds to it.
diff --git a/scripts/__tests__/lint-no-eql-registry-pins.test.mjs b/scripts/__tests__/lint-no-eql-registry-pins.test.mjs
index 06373c111..21e570f45 100644
--- a/scripts/__tests__/lint-no-eql-registry-pins.test.mjs
+++ b/scripts/__tests__/lint-no-eql-registry-pins.test.mjs
@@ -9,10 +9,12 @@ import {
   declarationId,
   EXEMPT_DECLARATIONS,
   EXPECTED_DECLARERS,
+  EXPECTED_SOURCES,
   lint,
   manifestFiles,
   npmDeclarations,
   report,
+  workspaceDeclarations,
 } from '../lint-no-eql-registry-pins.mjs'
 import { REPO_ROOT } from './lib/repo-root.mjs'
 import { readWorkflow, workflowFiles } from './lib/workflows.mjs'
@@ -284,6 +286,325 @@ describe('npm: what counts as in-tree', () => {
   })
 })
 
+describe('npm: the spellings a name-keyed scan walks past', () => {
+  const pkg = (json) => npmDeclarations('package.json', JSON.stringify(json))
+
+  it('reads a NESTED npm override', () => {
+    // npm's overrides are a tree, not a flat map: this pins EQL only under
+    // `some-pkg`, and a scan that reads `overrides['@cipherstash/eql']` sees an
+    // empty result and reports the tree clean.
+    const found = pkg({
+      overrides: { 'some-pkg': { '@cipherstash/eql': '3.0.4' } },
+    })
+    expect(found).toHaveLength(1)
+    expect(found[0]).toMatchObject({
+      table: 'overrides.some-pkg',
+      spec: '3.0.4',
+      inTree: false,
+    })
+  })
+
+  it('reads an override nested more than one level deep', () => {
+    expect(
+      pkg({
+        overrides: { a: { b: { '@cipherstash/eql': '3.0.4' } } },
+      })[0],
+    ).toMatchObject({ table: 'overrides.a.b', inTree: false })
+  })
+
+  it("reads npm's `.` self-target spelling", () => {
+    // `{"@cipherstash/eql": {".": "3.0.4"}}` pins the package itself and scopes
+    // further overrides beneath it. The version is on the CHILD key.
+    expect(
+      pkg({ overrides: { '@cipherstash/eql': { '.': '3.0.4' } } })[0],
+    ).toMatchObject({ spec: '3.0.4', inTree: false })
+  })
+
+  it("reads pnpm's `parent>child` override selector", () => {
+    expect(
+      pkg({ pnpm: { overrides: { 'some-pkg>@cipherstash/eql': '3.0.4' } } })[0],
+    ).toMatchObject({ table: 'pnpm.overrides', inTree: false })
+  })
+
+  it('reads an override key carrying a version selector', () => {
+    expect(
+      pkg({ pnpm: { overrides: { '@cipherstash/eql@<3.0.5': '3.0.4' } } })[0],
+    ).toMatchObject({ inTree: false })
+  })
+
+  it("reads yarn's `**/` resolutions glob", () => {
+    expect(
+      pkg({ resolutions: { '**/@cipherstash/eql': '3.0.4' } })[0],
+    ).toMatchObject({ table: 'resolutions', inTree: false })
+  })
+
+  it('does not flag a neighbouring package whose name starts the same', () => {
+    // `@cipherstash/eql-extras` is not `@cipherstash/eql`. A prefix match here
+    // makes the linter cry wolf, and the fix for a linter that cries wolf is
+    // always to weaken it.
+    expect(
+      pkg({ dependencies: { '@cipherstash/eql-extras': '1.0.0' } }),
+    ).toEqual([])
+    expect(
+      pkg({ overrides: { other: { '@cipherstash/eqlx': '3.0.4' } } }),
+    ).toEqual([])
+  })
+
+  it('reads a RENAMED dependency whose value aliases the package', () => {
+    // The name is on the right-hand side. Keying the scan on the dependency
+    // name misses this entirely — it installs @cipherstash/eql@3.0.4 from the
+    // registry under another name.
+    const found = pkg({
+      dependencies: { 'eql-legacy': 'npm:@cipherstash/eql@3.0.4' },
+    })
+    expect(found).toHaveLength(1)
+    expect(found[0]).toMatchObject({
+      key: 'eql-legacy',
+      form: 'alias',
+      inTree: false,
+    })
+  })
+
+  it('accepts the in-tree spelling of an alias', () => {
+    // `workspace:<name>@<range>` is how an aliased dep names a workspace
+    // package. It resolves in-tree, so it is not an offender.
+    expect(
+      pkg({
+        dependencies: { 'eql-legacy': 'workspace:@cipherstash/eql@^' },
+      })[0],
+    ).toMatchObject({ inTree: true, form: 'workspace' })
+  })
+
+  it('ignores an alias pointing at some other package', () => {
+    expect(pkg({ dependencies: { x: 'npm:lodash@4' } })).toEqual([])
+  })
+
+  it('reads an alias hidden in an override', () => {
+    expect(
+      pkg({ overrides: { 'eql-legacy': 'npm:@cipherstash/eql@3.0.4' } })[0],
+    ).toMatchObject({ form: 'alias', inTree: false })
+  })
+
+  it('names the declaration by the package, not by the key it was found under', () => {
+    // `EXPECTED_DECLARERS` and `EXEMPT_DECLARATIONS` are keyed `<file> ::
+    // <dependency>`. If an alias were filed under its alias name, an exemption
+    // could never be written for it and the two lists would drift apart from
+    // the scan.
+    expect(
+      declarationId(
+        pkg({
+          dependencies: { 'eql-legacy': 'npm:@cipherstash/eql@3.0.4' },
+        })[0],
+      ),
+    ).toBe('package.json :: @cipherstash/eql')
+  })
+
+  it('reports the offending KEY, so the reader can find the line', () => {
+    const { code, err } = report({
+      ids: ['x :: y'],
+      declarations: [],
+      exempted: [],
+      staleExemptions: [],
+      unreasonedExemptions: [],
+      missingExpected: [],
+      missingSources: [],
+      offenders: [
+        {
+          file: 'package.json',
+          dependency: '@cipherstash/eql',
+          key: 'eql-legacy',
+          table: 'dependencies',
+          spec: 'npm:@cipherstash/eql@3.0.4',
+        },
+      ],
+    })
+    expect(code).toBe(1)
+    expect(err).toContain('eql-legacy')
+  })
+
+  it('flags a nested override end to end', () => {
+    const root = tree({
+      'package.json': '{"overrides":{"some-pkg":{"@cipherstash/eql":"3.0.4"}}}',
+    })
+    expect(run(root).exitCode).toBe(1)
+  })
+})
+
+describe('pnpm-workspace.yaml: the file no manifest scan opens', () => {
+  const declarations = (yaml) =>
+    workspaceDeclarations('pnpm-workspace.yaml', yaml)
+
+  it('is collected by the walk', () => {
+    // The hole this whole block is about: pnpm 10 reads `overrides` from here,
+    // and the scan only ever opened `Cargo.toml` and `package.json`.
+    const root = tree({ 'pnpm-workspace.yaml': 'packages:\n  - packages/*\n' })
+    expect(manifestFiles(root)).toContain('pnpm-workspace.yaml')
+  })
+
+  it('reads a top-level `overrides:` entry', () => {
+    expect(
+      declarations("overrides:\n  '@cipherstash/eql': 3.0.4\n")[0],
+    ).toMatchObject({
+      file: 'pnpm-workspace.yaml',
+      dependency: '@cipherstash/eql',
+      table: 'overrides',
+      spec: '3.0.4',
+      inTree: false,
+    })
+  })
+
+  it('reads an override written as a version selector', () => {
+    // The shape every other override in this repo's file is written in.
+    expect(
+      declarations("overrides:\n  '@cipherstash/eql@<3.0.5': 3.0.4\n"),
+    ).toHaveLength(1)
+  })
+
+  it('reads a `parent>child` override', () => {
+    expect(
+      declarations("overrides:\n  'stash>@cipherstash/eql': 3.0.4\n"),
+    ).toHaveLength(1)
+  })
+
+  it('accepts a `workspace:` override', () => {
+    expect(
+      declarations("overrides:\n  '@cipherstash/eql': workspace:^\n")[0],
+    ).toMatchObject({ inTree: true })
+  })
+
+  it('reads a named catalog entry', () => {
+    // A catalog is the other way to move what installs: every manifest keeps
+    // saying `catalog:repo` while the version behind it changes here.
+    expect(
+      declarations("catalogs:\n  repo:\n    '@cipherstash/eql': 3.0.4\n")[0],
+    ).toMatchObject({ table: 'catalogs.repo', spec: '3.0.4', inTree: false })
+  })
+
+  it('reads the default catalog', () => {
+    expect(
+      declarations("catalog:\n  '@cipherstash/eql': 3.0.4\n")[0],
+    ).toMatchObject({ table: 'catalog', inTree: false })
+  })
+
+  it('leaves the rest of the file alone', () => {
+    // The real file carries a dozen security overrides and two catalogs. A
+    // reader that flagged any of them would be turned off within the week.
+    expect(
+      declarations(
+        [
+          'packages:',
+          '  - packages/*',
+          'catalogs:',
+          '  repo:',
+          '    typescript: 5.9.3',
+          'overrides:',
+          "  'next@<15.5.18': '~15.5.18'",
+          "  'lodash@<4.18.0': '^4.18.0'",
+          'minimumReleaseAge: 10080',
+        ].join('\n'),
+      ),
+    ).toEqual([])
+  })
+
+  it('flags a workspace-level override end to end', () => {
+    // The mutation check, as a test: plant the pin the linter could not see
+    // and confirm it now exits 1.
+    const root = tree({
+      'pnpm-workspace.yaml':
+        "packages:\n  - packages/*\noverrides:\n  '@cipherstash/eql': 3.0.4\n",
+      'packages/a/package.json':
+        '{"dependencies":{"@cipherstash/eql":"workspace:^"}}',
+    })
+    expect(run(root).exitCode).toBe(1)
+    expect(run(root).output).toContain('pnpm-workspace.yaml')
+  })
+
+  it('flags a catalog entry end to end', () => {
+    const root = tree({
+      'pnpm-workspace.yaml':
+        "packages:\n  - packages/*\ncatalogs:\n  repo:\n    '@cipherstash/eql': 3.0.4\n",
+    })
+    expect(run(root).exitCode).toBe(1)
+  })
+
+  it('treats `catalog:` in a manifest as a registry pin, not as a deferral', () => {
+    // Cargo's `workspace = true` is accepted because the workspace root's entry
+    // is scanned as a declaration in its own right. `catalog:` is NOT given the
+    // same treatment: a catalog holds version ranges, so the deferral has no
+    // in-tree answer to defer to. Flagging both ends is deliberate.
+    expect(
+      npmDeclarations(
+        'package.json',
+        '{"dependencies":{"@cipherstash/eql":"catalog:repo"}}',
+      )[0],
+    ).toMatchObject({ inTree: false, form: 'catalog' })
+  })
+})
+
+describe('the new source has a floor of its own', () => {
+  it('is satisfied by the real tree', () => {
+    expect(lint().missingSources).toEqual([])
+    // And the floor needs a floor, for the same reason EXPECTED_DECLARERS does:
+    // an emptied list satisfies "nothing missing" trivially.
+    expect(EXPECTED_SOURCES).toContain('pnpm-workspace.yaml')
+  })
+
+  it('notices a source that is not there at all', () => {
+    const root = tree({ 'packages/a/package.json': '{"dependencies":{}}' })
+    expect(
+      lint({ root, expected: [], exemptions: new Map() }).missingSources,
+    ).toEqual(['pnpm-workspace.yaml'])
+  })
+
+  it('notices a source that did not parse, rather than reading it as clean', () => {
+    // The failure mode this floor exists for. A YAML file that js-yaml refuses
+    // contributes no declarations — which is indistinguishable from a file with
+    // no overrides in it, and one of those two is a linter that stopped working.
+    const root = tree({
+      'pnpm-workspace.yaml': 'packages:\n  - a\n   bad indent: [\n',
+    })
+    expect(
+      lint({ root, expected: [], exemptions: new Map() }).missingSources,
+    ).toEqual(['pnpm-workspace.yaml'])
+  })
+
+  it('notices a source emptied out', () => {
+    const root = tree({ 'pnpm-workspace.yaml': '\n# nothing here\n' })
+    expect(
+      lint({ root, expected: [], exemptions: new Map() }).missingSources,
+    ).toEqual(['pnpm-workspace.yaml'])
+  })
+
+  it('exits 2 — not 0 — when a source could not be read', () => {
+    const { code, err } = report({
+      ids: [],
+      declarations: [],
+      offenders: [],
+      exempted: [],
+      staleExemptions: [],
+      unreasonedExemptions: [],
+      missingExpected: [],
+      missingSources: ['pnpm-workspace.yaml'],
+    })
+    expect(code).toBe(2)
+    expect(err).toContain('pnpm-workspace.yaml')
+  })
+
+  it('reports an unreadable source ahead of any offender it found', () => {
+    const { code } = report({
+      ids: ['x :: y'],
+      declarations: [],
+      offenders: [{ file: 'a', dependency: 'b', spec: '"1.0"' }],
+      exempted: [],
+      staleExemptions: [],
+      unreasonedExemptions: [],
+      missingExpected: [],
+      missingSources: ['pnpm-workspace.yaml'],
+    })
+    expect(code).toBe(2)
+  })
+})
+
 describe('the scan reports what it finds', () => {
   it('flags a registry pin anywhere in a tree', () => {
     const root = tree({
@@ -334,6 +655,7 @@ describe('the linter fails when its own configuration goes stale', () => {
     staleExemptions: [],
     unreasonedExemptions: [],
     missingExpected: [],
+    missingSources: [],
   }
 
   it('exits 2 — not 1 — when an expected declarer disappears', () => {
diff --git a/scripts/lint-no-eql-registry-pins.mjs b/scripts/lint-no-eql-registry-pins.mjs
index e605f1cfe..7eb86ec13 100644
--- a/scripts/lint-no-eql-registry-pins.mjs
+++ b/scripts/lint-no-eql-registry-pins.mjs
@@ -30,7 +30,28 @@
  *
  * npm: the specifier starts with `workspace:`. Nothing else — `link:` and
  * `file:` would resolve in-tree too, but they bypass the version range that
- * `workspace:^` exists to express, and no manifest here uses them.
+ * `workspace:^` exists to express, and no manifest here uses them. `catalog:`
+ * is NOT given Cargo's `workspace = true` treatment: a catalog entry holds a
+ * version range, so the deferral has no in-tree answer to defer to. Both ends
+ * are flagged — the manifest that says `catalog:` and the catalog entry itself.
+ *
+ * ## What gets read
+ *
+ * Every `Cargo.toml` and `package.json`, and `pnpm-workspace.yaml`. The last
+ * one is not a package manifest and no manifest scan would reach it, which is
+ * exactly why it matters: pnpm 10 reads `overrides` and `catalogs` from there,
+ * so an entry in that file moves what actually installs while every
+ * `workspace:^` in the tree still reads correct. The file says so itself, in a
+ * comment above its own `overrides:` block.
+ *
+ * Three shapes get read that a name-keyed scan walks straight past, and all
+ * three install `@cipherstash/eql` from the registry:
+ *
+ *   - a NESTED npm override — `{"overrides": {"pkg": {"@cipherstash/eql": …}}}`
+ *   - a SELECTOR key — `@cipherstash/eql@<3.0.5`, `pkg>@cipherstash/eql`, or
+ *     a yarn `resolutions` key carrying a glob prefix
+ *   - an ALIAS, where the package name is on the right-hand side —
+ *     `{"eql-legacy": "npm:@cipherstash/eql@3.0.4"}`
  *
  * ## Exemptions
  *
@@ -48,15 +69,16 @@
  *
  * - `0` — every declaration is in-tree or explicitly exempt.
  * - `1` — it ran and found a registry pin. Fix the manifest.
- * - `2` — it could not do its job: the scan matched less than it must, or an
- *   exemption is excusing nothing. Both mean the linter's own configuration is
- *   wrong, which is a different thing to go and fix, and must never be mistaken
- *   for a pass.
+ * - `2` — it could not do its job: a source it depends on would not read, the
+ *   scan matched less than it must, or an exemption is excusing nothing. All
+ *   three mean the linter's own configuration is wrong, which is a different
+ *   thing to go and fix, and must never be mistaken for a pass.
  */
 import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join, relative, resolve, sep } from 'node:path'
+import { basename, join, relative, resolve, sep } from 'node:path'
 import process from 'node:process'
 import { fileURLToPath } from 'node:url'
+import yaml from 'js-yaml'
 
 const REPO_ROOT = resolve(import.meta.dirname, '..')
 
@@ -64,6 +86,15 @@ const REPO_ROOT = resolve(import.meta.dirname, '..')
 const CARGO_DEPENDENCY = 'eql-bindings'
 const NPM_DEPENDENCY = '@cipherstash/eql'
 
+/**
+ * The one file pnpm resolves dependencies from that is not a package manifest.
+ *
+ * Only the repo root's copy is read by pnpm, but the walk collects every one it
+ * finds: a nested copy is inert to pnpm and therefore the perfect place to
+ * stage a pin, and reading it costs nothing.
+ */
+const WORKSPACE_FILE = 'pnpm-workspace.yaml'
+
 /**
  * Directories the walk does not descend into.
  *
@@ -104,6 +135,22 @@ export const EXPECTED_DECLARERS = [
   `packages/stack/package.json :: ${NPM_DEPENDENCY}`,
 ]
 
+/**
+ * Non-manifest sources the scan must have read AND understood, as the floor on
+ * those sources — the same idea as `EXPECTED_DECLARERS`, for a file that
+ * declares nothing today.
+ *
+ * `EXPECTED_DECLARERS` cannot cover `pnpm-workspace.yaml`, because a clean tree
+ * has no EQL entry in it: "found no declarations there" is the correct answer
+ * and is also what a renamed file, a `SKIP_DIRS` entry that swallowed it, or a
+ * YAML parse failure produce. Those are indistinguishable by their result, so
+ * this list checks the antecedent instead: the file was opened and it parsed.
+ *
+ * Held as a minimum, checked with exit 2, for the reason in the header: a scan
+ * that lost a source has not passed.
+ */
+export const EXPECTED_SOURCES = [WORKSPACE_FILE]
+
 /**
  * Declarations allowed to name a registry version, each with the reason.
  *
@@ -124,7 +171,17 @@ export const EXEMPT_DECLARATIONS = new Map([
   ],
 ])
 
-/** Every `Cargo.toml` and `package.json` under `root`, repo-relative. */
+/** Files this scan reads, by name. */
+const SCANNED_FILES = new Set(['Cargo.toml', 'package.json', WORKSPACE_FILE])
+
+/**
+ * Every `Cargo.toml`, `package.json` and `pnpm-workspace.yaml` under `root`,
+ * repo-relative.
+ *
+ * The workspace file is here because pnpm reads dependency resolution from it —
+ * see the header. It is not a package manifest, and a scan built around package
+ * manifests is exactly what would leave it out.
+ */
 export function manifestFiles(root) {
   const found = []
   const walk = (abs) => {
@@ -132,7 +189,7 @@ export function manifestFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue
         walk(join(abs, entry.name))
-      } else if (entry.name === 'Cargo.toml' || entry.name === 'package.json') {
+      } else if (SCANNED_FILES.has(entry.name)) {
         found.push(join(abs, entry.name))
       }
     }
@@ -243,6 +300,114 @@ export function cargoDeclarations(file, source) {
   return found
 }
 
+const escapeForRegExp = (literal) =>
+  literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+/**
+ * Whether an entry KEY names the npm package.
+ *
+ * Not an equality test, because none of the four ways to write the key is a
+ * bare package name:
+ *
+ *     @cipherstash/eql@<3.0.5     a version selector (npm and pnpm)
+ *     some-pkg>@cipherstash/eql   pnpm's scoped override
+ *     a/b/@cipherstash/eql        a resolutions path — and, with yarn's `**`
+ *                                 glob in front of it, a resolutions glob
+ *
+ * So: the name, at the end of the key, preceded by nothing or by a `/` or `>`
+ * boundary, optionally followed by one `@<range>`. The boundary is what keeps
+ * `@cipherstash/eql-extras` from matching — a prefix match here would make the
+ * linter cry wolf, and the fix for a linter that cries wolf is always to
+ * weaken it.
+ */
+const NPM_KEY = new RegExp(
+  `(^|[>/])${escapeForRegExp(NPM_DEPENDENCY)}(@[^@]*)?$`,
+)
+
+/**
+ * Whether an entry VALUE aliases the npm package — `"eql-legacy":
+ * "npm:@cipherstash/eql@3.0.4"`.
+ *
+ * The package name is on the RIGHT-hand side here, so a scan that looks only at
+ * keys never sees it: the manifest declares no dependency called
+ * `@cipherstash/eql` and installs one anyway.
+ */
+const NPM_ALIAS = new RegExp(
+  `^(?:npm|workspace|jsr):${escapeForRegExp(NPM_DEPENDENCY)}(?:@|$)`,
+)
+
+/**
+ * Classify an npm specifier. Only `workspace:` is in-tree — see the header.
+ *
+ * `catalog:` is called out separately from a plain version because the fix is
+ * different: the pin it defers to lives in `pnpm-workspace.yaml`, not in the
+ * manifest the reader is looking at.
+ */
+function classifyNpmSpec(spec) {
+  if (spec.startsWith('workspace:')) return { inTree: true, form: 'workspace' }
+  if (spec.startsWith('npm:')) return { inTree: false, form: 'alias' }
+  if (spec.startsWith('catalog:')) return { inTree: false, form: 'catalog' }
+  return { inTree: false, form: 'version' }
+}
+
+/**
+ * Walk one dependency/override/catalog table, recursively, collecting every
+ * entry that names the npm package by either side.
+ *
+ * Recursion is for npm's nested overrides, which are a TREE and not a flat map:
+ *
+ *     { "overrides": { "some-pkg": { "@cipherstash/eql": "3.0.4" } } }
+ *
+ * Reading only the top level of `overrides` finds nothing there and reports the
+ * tree clean, while the install resolves 3.0.4 from the registry.
+ *
+ * YAML scalars are coerced: `'@cipherstash/eql': 3.0` parses as the NUMBER 3
+ * under YAML 1.1, and dropping non-strings would drop exactly that pin.
+ */
+function collectNpmEntries(file, table, entries, found) {
+  if (!entries || typeof entries !== 'object' || Array.isArray(entries)) return
+  for (const [key, value] of Object.entries(entries)) {
+    const named = NPM_KEY.test(key)
+    const scalar =
+      typeof value === 'string' ||
+      typeof value === 'number' ||
+      typeof value === 'boolean'
+        ? String(value)
+        : null
+
+    if (scalar !== null) {
+      if (named || NPM_ALIAS.test(scalar)) {
+        found.push({
+          file,
+          // Always the package, never the key it was found under: both
+          // hand-maintained lists are keyed `<file> :: <dependency>`, so an
+          // alias filed under its alias name could never be exempted.
+          dependency: NPM_DEPENDENCY,
+          table,
+          key,
+          spec: scalar,
+          ...classifyNpmSpec(scalar),
+        })
+      }
+      continue
+    }
+    if (!value || typeof value !== 'object') continue
+    // npm's nested form: `.` pins the package the key names, and the sibling
+    // keys are overrides scoped beneath it.
+    if (named && typeof value['.'] === 'string') {
+      found.push({
+        file,
+        dependency: NPM_DEPENDENCY,
+        table,
+        key,
+        spec: value['.'],
+        ...classifyNpmSpec(value['.']),
+      })
+    }
+    collectNpmEntries(file, `${table}.${key}`, value, found)
+  }
+}
+
 /**
  * Every declaration of `NPM_DEPENDENCY` in one `package.json`.
  *
@@ -254,7 +419,8 @@ export function cargoDeclarations(file, source) {
  * A manifest that does not parse contributes nothing rather than throwing —
  * `package.json` syntax is checked by every other tool in the repo, and a
  * linter that dies on someone else's broken file reports its own crash instead
- * of the thing it was asked about.
+ * of the thing it was asked about. The manifests that matter are floored by
+ * `EXPECTED_DECLARERS`, so one of them going unreadable is exit 2 anyway.
  */
 export function npmDeclarations(file, source) {
   let manifest
@@ -263,6 +429,7 @@ export function npmDeclarations(file, source) {
   } catch {
     return []
   }
+  if (!manifest || typeof manifest !== 'object') return []
   const tables = [
     ['dependencies', manifest.dependencies],
     ['devDependencies', manifest.devDependencies],
@@ -274,32 +441,94 @@ export function npmDeclarations(file, source) {
   ]
   const found = []
   for (const [table, entries] of tables) {
-    const spec = entries?.[NPM_DEPENDENCY]
-    if (typeof spec !== 'string') continue
-    found.push({
-      file,
-      dependency: NPM_DEPENDENCY,
-      table,
-      spec,
-      inTree: spec.startsWith('workspace:'),
-      form: spec.startsWith('workspace:') ? 'workspace' : 'version',
-    })
+    collectNpmEntries(file, table, entries, found)
   }
   return found
 }
 
-/** Every declaration of either dependency under `root`. */
-export function scanTree(root) {
+/**
+ * `pnpm-workspace.yaml` as an object, or `null` if it would not read.
+ *
+ * `null` is a first-class answer here rather than an empty result, because
+ * "parsed, and declares nothing" is the normal state of this file and must not
+ * be spelled the same way as "did not parse". `EXPECTED_SOURCES` turns the
+ * difference into exit 2.
+ *
+ * A YAML library is used, unlike `scripts/release-gate.mjs`, which hand-parses
+ * the same file with node builtins and says why in its header: that script runs
+ * in the publishing gate on every push to main, where an import obliges a cold
+ * full-workspace install. This one runs as an ordinary lint job that has
+ * already installed, and it has to read `overrides` keys and nested `catalogs`
+ * maps rather than one flat sequence of scalars.
+ */
+export function parseWorkspace(source) {
+  let config
+  try {
+    config = yaml.load(source)
+  } catch {
+    return null
+  }
+  return config && typeof config === 'object' && !Array.isArray(config)
+    ? config
+    : null
+}
+
+/**
+ * Every declaration of `NPM_DEPENDENCY` in a parsed `pnpm-workspace.yaml`.
+ *
+ * `overrides` is the one that matters — pnpm 10 reads it from here, and the
+ * file's own comment says a top-level npm-format `overrides` block in
+ * `package.json` is silently ignored, which makes this the ONLY place a
+ * workspace-wide pin can be written and take effect.
+ *
+ * `catalog` / `catalogs` are read for the same reason one level along: every
+ * manifest keeps saying `catalog:repo` while the version behind it moves.
+ */
+function workspaceConfigDeclarations(file, config) {
   const found = []
+  collectNpmEntries(file, 'overrides', config.overrides, found)
+  collectNpmEntries(file, 'catalog', config.catalog, found)
+  const catalogs = config.catalogs
+  if (catalogs && typeof catalogs === 'object' && !Array.isArray(catalogs)) {
+    for (const [name, entries] of Object.entries(catalogs)) {
+      collectNpmEntries(file, `catalogs.${name}`, entries, found)
+    }
+  }
+  return found
+}
+
+/** `workspaceConfigDeclarations`, from source text. Empty if it would not parse. */
+export function workspaceDeclarations(file, source) {
+  const config = parseWorkspace(source)
+  return config ? workspaceConfigDeclarations(file, config) : []
+}
+
+/**
+ * Every declaration of either dependency under `root`, plus the files the scan
+ * successfully read AND understood.
+ *
+ * The second half is what `EXPECTED_SOURCES` is measured against. A
+ * `pnpm-workspace.yaml` that does not parse is deliberately left out of it: it
+ * contributes no declarations, which is indistinguishable from a file with no
+ * EQL entry in it, and one of those two is a linter that stopped working.
+ */
+export function scanTree(root) {
+  const declarations = []
+  const sources = []
   for (const rel of manifestFiles(root)) {
     const source = readFileSync(join(root, rel), 'utf8')
-    found.push(
-      ...(rel.endsWith('Cargo.toml')
-        ? cargoDeclarations(rel, source)
-        : npmDeclarations(rel, source)),
-    )
+    if (rel.endsWith('Cargo.toml')) {
+      declarations.push(...cargoDeclarations(rel, source))
+    } else if (basename(rel) === WORKSPACE_FILE) {
+      const config = parseWorkspace(source)
+      if (!config) continue
+      declarations.push(...workspaceConfigDeclarations(rel, config))
+    } else {
+      declarations.push(...npmDeclarations(rel, source))
+    }
+    sources.push(rel)
   }
-  return found
+  return { declarations, sources }
 }
 
 /** The id a declaration is named by, in both hand-maintained lists. */
@@ -315,8 +544,9 @@ export function lint({
   root = REPO_ROOT,
   exemptions = EXEMPT_DECLARATIONS,
   expected = EXPECTED_DECLARERS,
+  sources = EXPECTED_SOURCES,
 } = {}) {
-  const declarations = scanTree(root)
+  const { declarations, sources: read } = scanTree(root)
   const ids = declarations.map(declarationId)
   const registryPinned = declarations
     .filter((d) => !d.inTree)
@@ -352,6 +582,10 @@ export function lint({
       .filter(([, reason]) => !String(reason ?? '').trim())
       .map(([id]) => id),
     missingExpected: expected.filter((id) => !ids.includes(id)),
+    // The same idea one level down: not "an expected declaration is missing"
+    // but "a file this scan depends on was never successfully read". A source
+    // that declares nothing today cannot be floored any other way.
+    missingSources: sources.filter((rel) => !read.includes(rel)),
   }
 }
 
@@ -365,7 +599,7 @@ export function lint({
  * exercises the SAME mapping the CLI uses, without a harness that rewrites this
  * file's source in order to make a branch reachable.
  *
- * Ordering is deliberate: both exit-2 branches are checked before offenders.
+ * Ordering is deliberate: every exit-2 branch is checked before offenders.
  * A scan that lost its subject cannot be trusted to have found every offender
  * either, and reporting "3 registry pins" from a broken scan sends the reader
  * to fix the wrong thing.
@@ -375,6 +609,21 @@ export function report(result) {
     ? result.ids.map((id) => `  ${id}`).join('\n')
     : '  (nothing — the scan matched no manifest)'
 
+  if (result.missingSources.length > 0) {
+    return {
+      code: 2,
+      err:
+        'This linter could not read a file it resolves dependencies from:\n\n' +
+        result.missingSources.map((rel) => `  ${rel}`).join('\n') +
+        '\n\nEither the file is gone, or it did not parse. Both leave the scan\n' +
+        'with nothing to say about it — and "no EQL entry in there" is also\n' +
+        'what a clean tree looks like, so this cannot be reported as a pass.\n' +
+        `pnpm reads \`overrides\` and \`catalogs\` from ${WORKSPACE_FILE}, which\n` +
+        'is the one place a workspace-wide pin can be written while every\n' +
+        '`workspace:^` in the tree still reads correct.\n',
+    }
+  }
+
   if (result.missingExpected.length > 0) {
     return {
       code: 2,
@@ -430,7 +679,9 @@ export function report(result) {
       result.offenders
         .map(
           (o) =>
-            `  ${o.file}${o.table ? ` [${o.table}]` : ''}\n      ${o.dependency} = ${o.spec}`,
+            // The KEY, not the dependency name: for an alias or a selector they
+            // differ, and the key is the string the reader has to go and find.
+            `  ${o.file}${o.table ? ` [${o.table}]` : ''}\n      ${o.key ?? o.dependency} = ${o.spec}`,
         )
         .join('\n') +
       `\n\n\`${CARGO_DEPENDENCY}\` (the Rust that EMITS EQL payloads) and\n` +
@@ -441,6 +692,10 @@ export function report(result) {
       'Resolve it in-tree instead:\n\n' +
       `    ${CARGO_DEPENDENCY} = { path = "../../../eql/crates/eql-bindings" }\n` +
       `    "${NPM_DEPENDENCY}": "workspace:^"\n\n` +
+      `If the offender is in ${WORKSPACE_FILE} or in an \`overrides\` block, the\n` +
+      'fix is to delete it: an override exists to move what installs, and there\n' +
+      'is nothing in-tree for it to move to that `workspace:^` does not already\n' +
+      'say.\n\n' +
       'If the manifest genuinely cannot take an in-tree specifier, add it to\n' +
       'EXEMPT_DECLARATIONS in this script WITH the reason. There is one such\n' +
       'case today and it is written up there.\n',
@@ -456,7 +711,7 @@ function main() {
     process.exit(2)
   }
 
-  // An argv override is a fixture run: the two hand-maintained lists describe
+  // An argv override is a fixture run: the three hand-maintained lists describe
   // THIS repo, so applying them to another tree would fail on every invocation
   // for a reason that has nothing to do with the tree being scanned.
   const scanningRepo = root === REPO_ROOT
@@ -465,6 +720,7 @@ function main() {
       root,
       expected: scanningRepo ? EXPECTED_DECLARERS : [],
       exemptions: scanningRepo ? EXEMPT_DECLARATIONS : new Map(),
+      sources: scanningRepo ? EXPECTED_SOURCES : [],
     }),
   )
   if (out) console.log(out)

From 810b069e7df9ff8c82b6c62f61893a01f28bb1af Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:27:03 +1000
Subject: [PATCH 13/20] docs(eql): correct the 3.0.5 blast radius, and cover
 the stale vendored space
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

THE BLAST RADIUS WAS OVERSTATED IN ONE DIRECTION AND MISSED ENTIRELY IN
ANOTHER. The changeset claimed the rename affects "Supabase / PostgREST,
since PostgREST calls functions rather than operators". It does not:
`eql_v3.jsonb_contains(jsonb, jsonb)` and `jsonb_contained_by(jsonb, jsonb)`
are byte-identical to 3.0.4, and those are the function-form entry points a
PostgREST deployment actually calls. The real exposure is hand-written SQL.
The schema-wide grant scripts in docs/reference/permissions.md pick the new
name up on their next run, and a stale per-function grant fails loudly
rather than silently granting nothing.

Underneath it sits a larger fact that had never been written down: the
installer opens with `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so EVERY EQL
install drops grants, functional indexes and dependent views — not just
this release. That is U-002 in the new upgrade note, and it is the item
with real operational consequences.

A STALE VENDORED MIGRATION DIRECTORY IS NEVER DETECTED. `migrationHash` is
computed over a package's own bytes, so a `migrations/cipherstash/`
generated against 1.0.0 is stale but internally intact and passes every
integrity check. `materialiseExtensionMigrationPackageIfMissing` skips by
existence while `refs/head.json` is re-emitted unconditionally, and that
asymmetry is the whole failure mode: the head ref demands an invariant the
frozen genesis edge does not provide. On an existing database the upgrade
still applies; on a fresh one `db init` refuses with `Operation
cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is not
allowed by policy.` — naming neither the directory nor the remedy.

There is no in-package lever for that message: the text comes from
@prisma-next/target-postgres and the operation id it interpolates is frozen
inside a published content-addressed artefact. So the README carries the
error string verbatim with the remedy, and a test pins the two together so
they cannot drift.

The changeset also asserted something false: `runContractSpaceSeedPhase` is
called from migration-plan.ts and nowhere else, so `migrate` alone never
seeds. Without `migration plan` first, the 3.0.5 directory never reaches
disk and `migrate` is a silent no-op leaving the database on the older
bundle. Pre-existing since 3.0.2, but this changeset stated it as fact.

The fixture is not a committed blob — the 1.0.0 baseline is reconstructed
from artefacts already in the tree and PROVED faithful by hashing to
sha256:fc495f7f..., the value 1.0.0 published. Content addressing makes
that an exact-bytes assertion. The `problems: []` claim was verified
load-bearing by tampering a byte and confirming hashMismatch fires.
---
 .changeset/eql-3-0-5-migration.md             |  48 +-
 .changeset/stack-prisma-upgrade-from-1-0-0.md |  16 +
 packages/eql/docs/upgrading/v3.0.5.md         | 162 +++++
 packages/eql/docs/upgrading/v3.0.md           |   8 +-
 packages/eql/packages/eql/CHANGELOG.md        |  17 +-
 packages/stack-prisma/README.md               |  35 +
 .../test/v3/stale-vendored-space.test.ts      | 596 ++++++++++++++++++
 7 files changed, 869 insertions(+), 13 deletions(-)
 create mode 100644 .changeset/stack-prisma-upgrade-from-1-0-0.md
 create mode 100644 packages/eql/docs/upgrading/v3.0.5.md
 create mode 100644 packages/stack-prisma/test/v3/stale-vendored-space.test.ts

diff --git a/.changeset/eql-3-0-5-migration.md b/.changeset/eql-3-0-5-migration.md
index 32bdea778..27479bed1 100644
--- a/.changeset/eql-3-0-5-migration.md
+++ b/.changeset/eql-3-0-5-migration.md
@@ -3,18 +3,43 @@
 ---
 
 Move the bundled EQL v3 migrations to **eql-3.0.5**, which renames the SQL
-function `eql_v3.ste_vec_contains` to `eql_v3.jsonb_document_contains`. The
-operators are unchanged (`@>` / `<@` on `public.eql_v3_json_search` behave
-exactly as before) — only callers that invoke the function **by name** are
-affected, which in practice means Supabase / PostgREST, since PostgREST calls
-functions rather than operators.
+function `eql_v3.ste_vec_contains` to `eql_v3.jsonb_document_contains`.
+
+**The blast radius is narrower than a renamed public function suggests.** The
+`@>` / `<@` operators on `public.eql_v3_json_search` behave exactly as before,
+and so do the two function-form entry points that exist for platforms without
+operator support — `eql_v3.jsonb_contains(jsonb, jsonb)` and
+`eql_v3.jsonb_contained_by(jsonb, jsonb)` are byte-identical to 3.0.4. Those
+are what a PostgREST caller invokes, so PostgREST callers on the documented
+surface are **not** affected. The renamed function is the typed implementation
+those operators dispatch into.
+
+**What does break is hand-written SQL naming the old function** — an
+application query, a view, an RLS policy, or a per-function
+`GRANT EXECUTE ON FUNCTION eql_v3.ste_vec_contains(…)`. After the upgrade
+those fail loudly (`function eql_v3.ste_vec_contains(…) does not exist`)
+rather than silently, but they fail. Grep your migrations, views and policies
+for `ste_vec_contains`.
+
+**Separately — and true of every EQL upgrade, not just this one:** the install
+bundle opens with `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so applying it
+destroys every grant on every object in `eql_v3` / `eql_v3_internal`, along
+with anything that depended on them (this is the same mechanism that drops
+functional indexes on encrypted columns). **Re-run your grant script after
+upgrading.** The schema-wide form EQL documents —
+`GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3 TO app_role` — picks the new
+name up on its own; a hand-written per-function grant has to be edited first.
 
 Two artefacts carry the new bundle:
 
 - A new upgrade edge, `20260814T0000_upgrade_eql_v3_3_0_5`, carrying the
   invariant `cipherstash:upgrade-eql-v3-bundle-3.0.5-v1`. Databases already
   running an earlier bundle re-install through this edge on the next
-  `prisma-next migrate`, exactly as they did for 3.0.2 and 3.0.4.
+  `prisma-next migration plan` followed by `prisma-next migrate`, exactly as
+  they did for 3.0.2 and 3.0.4. **`migrate` alone is not enough** — the seed
+  phase that copies a new migration package into your repo runs only from
+  `migration plan`, so without it the 3.0.5 directory never reaches disk and
+  `migrate` is a silent no-op that leaves the database on the older bundle.
 - The baseline install migration `20260601T0100_install_eql_v3_bundle`, whose
   baked bundle moves to 3.0.5 and which gains a fourth no-SQL carrier op for
   the new invariant. Fresh databases therefore land on 3.0.5 from the single
@@ -23,11 +48,18 @@ Two artefacts carry the new bundle:
 **Action required.** The baseline's bytes — and so its `migrationHash` — have
 changed. If your project already has a `migrations/cipherstash/` directory
 generated against `@cipherstash/stack-prisma@1.0.0`, delete that directory and
-re-run `prisma-next migration plan` (or `migrate`); the seed phase regenerates
-it byte-identical to the shipped artefacts. Your database keeps its markers, so
+re-run `prisma-next migration plan`; the seed phase regenerates it
+byte-identical to the shipped artefacts. Your database keeps its markers, so
 already-applied invariants are not re-run — the only new work is the 3.0.5
 upgrade edge.
 
+If you skip the delete, nothing warns you: a vendored baseline is stale but
+internally intact, so it passes every integrity check. On an existing database
+the upgrade still applies correctly; on a **fresh** one, `db init` refuses with
+`Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is
+not allowed by policy.` — an error that names neither the directory nor the
+remedy. See "Upgrading from 1.0.0" in the package README.
+
 **Why the baseline was re-emitted rather than left frozen.** These artefacts are
 content-addressed and normally append-only: an EQL bump ships as a new upgrade
 directory and published directories are never rewritten. That rule cannot be
diff --git a/.changeset/stack-prisma-upgrade-from-1-0-0.md b/.changeset/stack-prisma-upgrade-from-1-0-0.md
new file mode 100644
index 000000000..311ae91a5
--- /dev/null
+++ b/.changeset/stack-prisma-upgrade-from-1-0-0.md
@@ -0,0 +1,16 @@
+---
+'@cipherstash/stack-prisma': patch
+---
+
+Document the 1.0.0 → 3.0.5 upgrade in the package README: why
+`migrations/cipherstash/` must be deleted and regenerated, what each Prisma Next
+command does if it is not, and the exact `db init` refusal
+(`Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is
+not allowed by policy.`) that a stale vendored directory produces on a fresh
+database.
+
+The behaviour worth knowing regardless of version: only `prisma-next migration
+plan` copies new migration packages into your repo. Running `migrate` or
+`db init` after upgrading this package without planning first silently leaves
+the database on the older EQL bundle — a stale vendored directory is internally
+intact, so it passes every integrity check and nothing reports a problem.
diff --git a/packages/eql/docs/upgrading/v3.0.5.md b/packages/eql/docs/upgrading/v3.0.5.md
new file mode 100644
index 000000000..874a44d14
--- /dev/null
+++ b/packages/eql/docs/upgrading/v3.0.5.md
@@ -0,0 +1,162 @@
+# Upgrading to EQL 3.0.5
+
+`3.0.5` is a patch release carrying one rename in the public `eql_v3` surface.
+It is a patch, not a major, for the reason 3.0.1 was: a patch reaches every
+consumer already on a `^3.x` range at their next install, and the affected
+call site is one that almost nobody writes by hand.
+
+This guide also records a second thing, which is **not** new in 3.0.5 but bites
+hardest at upgrade time and has never had a note of its own: applying the EQL
+bundle drops and recreates its schemas, so grants and dependent objects do not
+survive it.
+
+## TL;DR
+
+1. `eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains` —
+   [U-001](#u-001-the-containment-implementation-is-renamed).
+2. Applying any EQL bundle destroys grants, indexes and dependent objects in
+   `eql_v3` / `eql_v3_internal`; re-apply them afterwards —
+   [U-002](#u-002-grants-and-dependent-objects-do-not-survive-an-install).
+
+## Compatibility
+
+| Surface | Status |
+| --- | --- |
+| `@>` / `<@` on `public.eql_v3_json_search` | **Unchanged.** Same operators, same results, same index behaviour. |
+| `eql_v3.jsonb_contains(jsonb, jsonb)` / `eql_v3.jsonb_contained_by(jsonb, jsonb)` | **Unchanged**, byte for byte. These are the function-form entry points for platforms without operator support — PostgREST included — and they are not affected by this release. |
+| `eql_v3.ste_vec_contains` | **Renamed** to `eql_v3.jsonb_document_contains` (both overloads) — see U-001. |
+| `eql_v3.to_ste_vec_query`, `eql_v3.ste_vec`, `eql_v3.jsonb_array` | **Unchanged.** The documented GIN index recipe still reads `USING gin ((eql_v3.to_ste_vec_query(col)::jsonb) jsonb_path_ops)`. |
+| Wire format, domains, index terms | **Unchanged.** No re-encryption, no data migration. |
+
+## Upgrade notes
+
+### U-001: The containment implementation is renamed
+
+**What changed.** `eql_v3.ste_vec_contains` is now
+`eql_v3.jsonb_document_contains`, in both overloads —
+`(jsonb[], jsonb)` and
+`(public.eql_v3_json_search, public.eql_v3_json_search)`. The body is
+unchanged. The old name is **removed**; there is no compatibility alias.
+
+**Why.** It was the last object in the public surface still carrying
+`ste_vec_` naming, after the SteVec entry and query surface became
+`jsonb_entry` / `jsonb_query`. `ste_vec` is an implementation detail of the
+encrypted representation; the operator family it backs is the `jsonb_*` one.
+
+**Who is affected.** Only SQL that names the function directly. In particular
+this is **not** the PostgREST story it might look like: PostgREST calls
+functions rather than operators, but the function-form containment entry points
+it calls are `eql_v3.jsonb_contains` and `eql_v3.jsonb_contained_by`, and both
+are unchanged. `jsonb_document_contains` is what the typed `@>` / `<@`
+operators dispatch into.
+
+So the affected callers are hand-written:
+
+- application queries, views or matviews naming `eql_v3.ste_vec_contains`
+- RLS policies whose `USING` / `WITH CHECK` expression names it
+- SQL functions or triggers that wrap it
+- a per-function grant, `GRANT EXECUTE ON FUNCTION eql_v3.ste_vec_contains(…)`
+
+**What to do.** Grep your migrations, policies and application SQL for
+`ste_vec_contains` and replace it with `jsonb_document_contains`. Nothing else
+changes — same arguments, same return, same semantics. The failure is loud
+(`function eql_v3.ste_vec_contains(…) does not exist`), so an unfixed caller
+errors rather than silently returning the wrong rows; a view or policy is the
+case to check first, because the error surfaces at query time rather than at
+upgrade time.
+
+**Verification.**
+
+```sql
+-- Must return two rows (the two overloads):
+SELECT p.oid::regprocedure
+FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+WHERE n.nspname = 'eql_v3' AND p.proname = 'jsonb_document_contains';
+
+-- Must return zero rows:
+SELECT p.oid::regprocedure
+FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+WHERE n.nspname = 'eql_v3' AND p.proname = 'ste_vec_contains';
+
+-- The operators are unchanged; this must still work:
+SELECT '{"sv": []}'::jsonb::public.eql_v3_json_search
+    @> '{"sv": []}'::jsonb::public.eql_v3_json_search;   -- true
+```
+
+### U-002: Grants and dependent objects do not survive an install
+
+**What changed.** Nothing — this has always been true, and it is recorded here
+because 3.0.5 is the first release whose *only* change is one that a reader
+might otherwise upgrade through without re-running their grants.
+
+**What to know.** The installer opens with:
+
+```sql
+DROP SCHEMA IF EXISTS eql_v3 CASCADE;
+CREATE SCHEMA eql_v3;
+DROP SCHEMA IF EXISTS eql_v3_internal CASCADE;
+CREATE SCHEMA eql_v3_internal;
+```
+
+`CASCADE` means every install — first install, upgrade, or re-apply — destroys
+everything in those two schemas *and* everything outside them that depended on
+their objects. That includes:
+
+- **all grants** on `eql_v3` / `eql_v3_internal` objects, including those from
+  `GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA …`, which is a point-in-time grant
+  and does not cover objects created later
+- **functional indexes** over the term extractors (`eql_v3.eq_term`,
+  `ord_term`, `ord_term_ore`, `match_term`, `to_ste_vec_query`) — these vanish
+  and queries fall back to sequential scans **without erroring**
+- **views, matviews and generated columns** whose definitions reference
+  `eql_v3` objects
+
+Your table columns and their data are untouched: the storage domains live in
+`public` precisely so they survive an EQL schema uninstall.
+
+**What to do.** After every install or upgrade, re-apply — in this order — your
+grant script and your index DDL, then `ANALYZE`. The schema-wide grant form in
+[permissions.md](../reference/permissions.md) picks up renamed and newly added
+functions on its own, which is one more reason to prefer it to per-function
+grants:
+
+```sql
+GRANT USAGE   ON SCHEMA eql_v3          TO app_role;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3          TO app_role;
+GRANT USAGE   ON SCHEMA eql_v3_internal TO app_role;
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3_internal TO app_role;
+```
+
+If you run the bundle through a migration runner, put the grants and the
+`CREATE INDEX` statements in a *new* migration alongside the upgrade — a runner
+skips migrations it has already applied, so the originals will not re-run.
+
+**Verification.**
+
+```sql
+-- Containment must be executable by the app role after the upgrade:
+SELECT has_function_privilege(
+  'app_role',
+  'eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search)',
+  'EXECUTE');   -- must be true
+
+-- And the functional indexes must still be there:
+SELECT indexname FROM pg_indexes
+WHERE indexdef LIKE '%eql_v3.%_term%' OR indexdef LIKE '%to_ste_vec_query%';
+```
+
+## Rollback
+
+U-001 is reversible by installing the 3.0.4 bundle, which restores the old
+function name. Nothing in the wire format or the stored data changes between
+3.0.4 and 3.0.5, so no re-encryption is involved in either direction — but note
+that rolling back re-runs the `DROP SCHEMA … CASCADE` in U-002, so grants and
+indexes need re-applying again afterwards.
+
+## See also
+
+- [Upgrading to EQL 3.0](./v3.0.md) — the breaking changes in the 3.0 line.
+- [Permissions reference](../reference/permissions.md) — what each query path
+  needs granted, and the schema-wide grant script.
+- [Database indexes](../reference/database-indexes.md) — the index recipes to
+  re-apply after an install.
diff --git a/packages/eql/docs/upgrading/v3.0.md b/packages/eql/docs/upgrading/v3.0.md
index 880f5eaac..573c63613 100644
--- a/packages/eql/docs/upgrading/v3.0.md
+++ b/packages/eql/docs/upgrading/v3.0.md
@@ -54,7 +54,7 @@ the `eql_v3` surface (U-001 through U-010 below).
 | Text bloom fuzzy match (`public.eql_v3_text_match` / `text_search` / `text_search_ore`) | **Changed.** `@>` / `<@` (`eql_v3.contains` / `contained_by`) → the single directional `@@` (`eql_v3.matches`); `@>` / `<@` now raise on these domains — see U-008. |
 | Empty-bloom fuzzy-match needle (`@@` / `eql_v3.matches`) | **Changed.** An empty needle bloom matched every row (vacuous containment); now `LIKE ''`-shaped — matches only empty-bloom values. Normal queries and the GIN index recipe unchanged — see U-011. |
 | Uninstaller lock footprint | **Grown.** The single-transaction uninstall takes ~6,400+ locks — at/over the default `max_locks_per_transaction = 64` cluster budget under concurrent load — see U-009. Installation unaffected. |
-| JSON containment (`public.eql_v3_json_search` `@>` / `<@`, `eql_v3.ste_vec_contains`) | **Unchanged.** Genuine containment keeps the containment vocabulary — see U-008. |
+| JSON containment (`public.eql_v3_json_search` `@>` / `<@`, `eql_v3.jsonb_document_contains`) | **Unchanged.** Genuine containment keeps the containment vocabulary — see U-008. (The implementation was called `eql_v3.ste_vec_contains` until 3.0.5 renamed it; the operators never changed. See [Upgrading to EQL 3.0.5](./v3.0.5.md).) |
 | Legacy `eql_v2` wire documentation (`docs/reference/schema/eql-payload-v2.*.schema.json`) | **Unchanged.** Stays `v: 2`. |
 
 ## Upgrade notes
@@ -609,7 +609,8 @@ order- and multiplicity-insensitive, one-sided fuzzy match: a `true` may be a
 false positive; a `false` never is. Naming it `contains` / `@>` promised
 substring/containment semantics it does not provide, and collided with the genuine
 containment surface on encrypted JSON (`public.eql_v3_json_search`,
-`eql_v3.ste_vec_contains`), which is unaffected and keeps `@>` / `<@`. This is the
+`eql_v3.jsonb_document_contains` — named `eql_v3.ste_vec_contains` before
+3.0.5), which is unaffected and keeps `@>` / `<@`. This is the
 SQL-layer counterpart of the SDK's `contains()` → `matches()` rename.
 
 **Who is affected.** Anyone with a query, view, or SDK/adapter that emits
@@ -767,7 +768,8 @@ equality on the extract surface; anyone calling `eql_v3.jsonb_array_elements_tex
   `eql_v3.jsonb_array_elements(col)` — its entry rows carry the grafted key
   header and are the decryptable unit.
 - Range queries, document-to-document containment (`@>` / `<@`,
-  `eql_v3.ste_vec_contains`), field/array access (`->`, `->>`), ordered
+  `eql_v3.jsonb_document_contains`, called `eql_v3.ste_vec_contains` before
+  3.0.5), field/array access (`->`, `->>`), ordered
   entry-to-entry comparison, `eql_v3.ord_term`, and `min` / `max` are unchanged.
   Entry-to-entry `=` / `<>` now fail loudly; use value-selector containment for
   exact equality.
diff --git a/packages/eql/packages/eql/CHANGELOG.md b/packages/eql/packages/eql/CHANGELOG.md
index 9de166a43..b770ea06e 100644
--- a/packages/eql/packages/eql/CHANGELOG.md
+++ b/packages/eql/packages/eql/CHANGELOG.md
@@ -8,8 +8,21 @@
   consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family,
   matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`,
   `jsonb_query`). The function backs the `json` `@>` / `<@` containment operators;
-  its behaviour is unchanged. Callers that invoke the function by name (Supabase /
-  PostgREST, which call functions rather than operators) must update the name.
+  its behaviour is unchanged.
+
+  **Who is affected is narrower than a rename usually implies.** The operators are
+  untouched, and so are the two function-form entry points a PostgREST deployment
+  actually calls — `eql_v3.jsonb_contains(jsonb, jsonb)` and
+  `eql_v3.jsonb_contained_by(jsonb, jsonb)` are byte-identical to 3.0.4. What
+  breaks is hand-written SQL that names `ste_vec_contains` directly: queries,
+  views, RLS policies, and per-function `GRANT`s. The schema-wide grant scripts in
+  `docs/reference/permissions.md` pick the new name up on their next run, and a
+  stale per-function grant fails loudly (`function … does not exist`) rather than
+  silently granting nothing. See [U-001](../../docs/upgrading/v3.0.5.md#u-001-the-containment-implementation-is-renamed),
+  and [U-002](../../docs/upgrading/v3.0.5.md#u-002-grants-and-dependent-objects-do-not-survive-an-install)
+  for the larger fact underneath it — the installer opens with
+  `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so *every* EQL install drops grants,
+  functional indexes and dependent views, not just this one.
 
   Released as a **patch**, matching 3.0.1, which shipped the fuzzy-match operator
   change (`@>` / `<@` → `@@`) at the same level. The parked changeset proposed
diff --git a/packages/stack-prisma/README.md b/packages/stack-prisma/README.md
index cc7367fe1..5e5197657 100644
--- a/packages/stack-prisma/README.md
+++ b/packages/stack-prisma/README.md
@@ -29,6 +29,41 @@ Declare encrypted columns directly in `schema.prisma`, and the framework's migra
 npm install @cipherstash/stack @cipherstash/stack-prisma
 ```
 
+### Upgrading from 1.0.0
+
+1.0.0 shipped the EQL v3 baseline migration at **eql-3.0.4**. Later versions bake
+**eql-3.0.5** into the same baseline directory
+(`20260601T0100_install_eql_v3_bundle`), so its bytes — and its `migrationHash` —
+changed. Migration packages are content-addressed and copied into your repo, and
+the CLI's seed phase never rewrites a directory that already exists, so a
+`migrations/cipherstash/` generated against 1.0.0 keeps the old baseline forever.
+
+**After upgrading, delete the vendored directory and regenerate it:**
+
+```bash
+rm -rf migrations/cipherstash
+npx prisma-next migration plan
+```
+
+Your database is untouched by this: markers are keyed by invariant, so
+already-applied invariants are not re-run and the only new work is the 3.0.5
+upgrade edge.
+
+Skipping this is not always fatal, which is why it is easy to miss:
+
+| You run | With a stale `migrations/cipherstash/` |
+| --- | --- |
+| `prisma-next migration plan` | Succeeds. The stale baseline is kept silently — there is no hash mismatch, because it is intact, just old. |
+| `prisma-next migrate` (existing database) | Correct: applies the 3.0.5 upgrade edge only. |
+| `prisma-next migrate` (fresh database) | Correct end state, but installs eql-3.0.4 and then immediately re-installs eql-3.0.5 over it. |
+| `prisma-next db init` (fresh database) | **Fails**: `Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is not allowed by policy.` `db init` is additive-only, and the stale baseline does not carry the 3.0.5 invariant, so the planner has to reach for the data-classed upgrade edge. The message does not say so — the remedy is the `rm -rf` above. |
+
+Note that only `prisma-next migration plan` copies new migration packages into
+your repo. If you upgrade the package and run `prisma-next migrate` or
+`db init` **without** planning first, the 3.0.5 upgrade is not on disk yet and is
+silently skipped — your database stays on the older bundle. Always run
+`migration plan` after upgrading.
+
 ## Quick start
 
 ```prisma
diff --git a/packages/stack-prisma/test/v3/stale-vendored-space.test.ts b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
new file mode 100644
index 000000000..75ebc7dc5
--- /dev/null
+++ b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
@@ -0,0 +1,596 @@
+/**
+ * What happens to a consumer who IGNORES the 3.0.5 changeset's "Action
+ * required" note — i.e. keeps a `migrations/cipherstash/` directory
+ * generated against `@cipherstash/stack-prisma@1.0.0` and upgrades the
+ * package underneath it.
+ *
+ * The 3.0.5 release re-emitted the published baseline
+ * (`20260601T0100_install_eql_v3_bundle`): its bytes, and so its
+ * `migrationHash`, changed from `sha256:fc495f7f…` to `sha256:1ae73282…`.
+ * These artefacts are content-addressed and normally append-only, so a
+ * re-emit is the one case the machinery was never designed for. The
+ * changeset tells consumers to delete the vendored directory and re-run
+ * `prisma-next migration plan`. That instruction is prose in a changelog:
+ * this suite pins what actually happens when it is not followed.
+ *
+ * The mechanism, established by reading the framework (no live database
+ * is involved in any of it):
+ *
+ *   - `migrationHash` is computed over a package's OWN bytes
+ *     (`verifyMigrationHash`), so a stale-but-intact vendored baseline is
+ *     SELF-CONSISTENT and passes every integrity check. Nothing anywhere
+ *     compares an on-disk package against the descriptor's shipped one.
+ *   - The CLI seed phase (`migration plan`) materialises descriptor
+ *     packages with `materialiseExtensionMigrationPackageIfMissing` — a
+ *     by-existence skip. The stale baseline is silently retained; only the
+ *     new 3.0.5 directory is written. `refs/head.json` IS overwritten.
+ *   - `db init` / `db update` / `migrate` then plan from the ON-DISK
+ *     graph only (`computeExtensionSpaceApplyPath`); the descriptor is
+ *     never consulted again.
+ *
+ * The suite is offline and deterministic — the fixture is reconstructed
+ * from artefacts already in this repo and proved byte-equivalent to the
+ * published 1.0.0 baseline by its content hash (see
+ * `STALE_1_0_0_BASELINE_HASH`). It therefore runs in the normal
+ * `pnpm --filter @cipherstash/stack-prisma test` suite with no env guard
+ * and no skip.
+ */
+import { mkdtemp, readFile, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { MigrationPlanOperation } from '@prisma-next/framework-components/control'
+import { computeMigrationHash } from '@prisma-next/migration-tools/hash'
+import {
+  materialiseExtensionMigrationPackageIfMissing,
+  readMigrationsDir,
+  writeMigrationPackage,
+} from '@prisma-next/migration-tools/io'
+import type { MigrationMetadata } from '@prisma-next/migration-tools/metadata'
+import type { MigrationOps } from '@prisma-next/migration-tools/package'
+import {
+  computeExtensionSpaceApplyPath,
+  emitContractSpaceArtefacts,
+  spaceMigrationDirectory,
+} from '@prisma-next/migration-tools/spaces'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import v3BaselineMetadata from '../../migrations/20260601T0100_install_eql_v3_bundle/migration.json' with {
+  type: 'json',
+}
+import headRef from '../../migrations/refs/head.json' with { type: 'json' }
+import cipherstashDescriptor from '../../src/exports/control'
+import { CIPHERSTASH_SPACE_ID } from '../../src/extension-metadata/constants'
+import {
+  CIPHERSTASH_V3_302_UPGRADE_MIGRATION_NAME,
+  CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME,
+  CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME,
+  CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+  CIPHERSTASH_V3_INVARIANTS,
+} from '../../src/extension-metadata/constants-v3'
+
+/**
+ * The `migrationHash` `@cipherstash/stack-prisma@1.0.0` published for
+ * `20260601T0100_install_eql_v3_bundle`, before the 3.0.5 re-emit. It is
+ * what a consumer's vendored copy still carries. Recorded here as the
+ * fixture's acceptance criterion, not as live history: the frozen set of
+ * CURRENT hashes lives in `migration-v3.test.ts`.
+ */
+const STALE_1_0_0_BASELINE_HASH =
+  'sha256:fc495f7f59e6d18ae8e3df594a38898263ca91f8f5fb5f625bff20d04a0d7223'
+
+/** The three invariants a 1.0.0 install recorded on the marker row. */
+const INVARIANTS_1_0_0 = [
+  CIPHERSTASH_V3_INVARIANTS.installBundle,
+  CIPHERSTASH_V3_INVARIANTS.upgradeBundle302,
+  CIPHERSTASH_V3_INVARIANTS.upgradeBundle304,
+] as const
+
+/**
+ * The runner's apply-time policy gate, reproduced. `db init` runs with
+ * `allowedOperationClasses: ['additive']`; the Postgres target's
+ * `enforcePolicyCompatibility` refuses the whole run on the first op
+ * outside that set, naming only the operation id and its class.
+ * (`migrate` and `db update` allow more classes — `migrate` allows all
+ * four, which is why the same on-disk state behaves differently there.)
+ */
+function opsRefusedByDbInitPolicy(
+  ops: ReadonlyArray<{ readonly id: string; readonly operationClass: string }>,
+): readonly string[] {
+  return ops.filter((op) => op.operationClass !== 'additive').map((op) => op.id)
+}
+
+/**
+ * The SQL target's op shape. `MigrationPlanOperation` (the framework's
+ * base type) carries only `id` / `label` / `operationClass` /
+ * `invariantId`; the `execute` / `postcheck` step lists are added by
+ * `@prisma-next/target-postgres` and are what this suite reads. Declared
+ * locally so the single widening cast lives in `asSqlOps` below rather
+ * than at every use site.
+ */
+interface SqlMigrationOp extends MigrationPlanOperation {
+  readonly execute: ReadonlyArray<{
+    readonly description: string
+    readonly sql: string
+  }>
+  readonly postcheck: ReadonlyArray<{
+    readonly description: string
+    readonly sql: string
+  }>
+}
+
+function asSqlOps(ops: MigrationOps): readonly SqlMigrationOp[] {
+  return ops as readonly SqlMigrationOp[]
+}
+
+function descriptorSpace() {
+  const space = cipherstashDescriptor.contractSpace
+  if (!space) throw new Error('descriptor ships no contractSpace')
+  return space
+}
+
+function descriptorPackage(dirName: string) {
+  const pkg = descriptorSpace().migrations.find((m) => m.dirName === dirName)
+  if (!pkg) throw new Error(`descriptor is missing ${dirName}`)
+  return pkg
+}
+
+/**
+ * Rebuild the 1.0.0 baseline package from artefacts still in this repo.
+ *
+ * Every byte is recoverable without a fixture blob: the 1.0.0 baseline's
+ * install SQL is the same eql-3.0.4 bundle the `20260728T0000` upgrade
+ * edge bakes (both pin `installSqlSha256` `63104a81…` — see
+ * `migration-v3.test.ts`), and the surrounding op shape differs from
+ * today's baseline only in the release string and the missing 3.0.5
+ * carrier op. The reconstruction is *proved* faithful by hashing it: the
+ * `migrationHash` test below demands `sha256:fc495f7f…`, the value 1.0.0
+ * published. Content addressing makes that an exact-bytes assertion, so
+ * this fixture cannot silently drift into "some old-looking baseline".
+ */
+function buildStale100Baseline(): {
+  readonly metadata: MigrationMetadata
+  readonly ops: readonly SqlMigrationOp[]
+} {
+  const to304 = (text: string): string => text.replaceAll('3.0.5', '3.0.4')
+  const shipped = asSqlOps(
+    descriptorPackage(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).ops,
+  )
+  const install = shipped[0]
+  const carrier302 = shipped[1]
+  const carrier304 = shipped[2]
+  const bundle304 = asSqlOps(
+    descriptorPackage(CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME).ops,
+  )[0]?.execute[0]?.sql
+  if (!install || !carrier302 || !carrier304 || bundle304 === undefined) {
+    throw new Error('shipped artefacts no longer have the expected op shape')
+  }
+
+  const ops: readonly SqlMigrationOp[] = [
+    {
+      ...install,
+      label: to304(install.label),
+      execute: [
+        {
+          description: to304(install.execute[0]?.description ?? ''),
+          sql: bundle304,
+        },
+      ],
+    },
+    // The 3.0.2 carrier is byte-identical across 1.0.0 and 3.0.5.
+    carrier302,
+    {
+      ...carrier304,
+      postcheck: carrier304.postcheck.map((check) => ({
+        description: to304(check.description),
+        sql: to304(check.sql),
+      })),
+    },
+  ]
+
+  const metadata: MigrationMetadata = {
+    ...descriptorPackage(CIPHERSTASH_V3_BASELINE_MIGRATION_NAME).metadata,
+    providedInvariants: [...INVARIANTS_1_0_0],
+    migrationHash: STALE_1_0_0_BASELINE_HASH,
+  }
+
+  return { metadata, ops }
+}
+
+/**
+ * Write a `migrations/cipherstash/` directory exactly as
+ * `@cipherstash/stack-prisma@1.0.0`'s seed phase would have left it: the
+ * 1.0.0 baseline, the two upgrade edges 1.0.0 shipped (both unchanged by
+ * the 3.0.5 release, so the shipped bytes ARE the 1.0.0 bytes), and a
+ * head ref demanding only the three 1.0.0 invariants.
+ */
+async function vendorStale100Space(migrationsDir: string): Promise<void> {
+  const spaceDir = spaceMigrationDirectory(migrationsDir, CIPHERSTASH_SPACE_ID)
+  const stale = buildStale100Baseline()
+
+  await emitContractSpaceArtefacts(migrationsDir, CIPHERSTASH_SPACE_ID, {
+    contract: descriptorSpace().contractJson,
+    contractDts: 'export {};\n',
+    headRef: { hash: headRef.hash, invariants: [...INVARIANTS_1_0_0] },
+  })
+
+  await writeMigrationPackage(
+    join(spaceDir, CIPHERSTASH_V3_BASELINE_MIGRATION_NAME),
+    stale.metadata,
+    stale.ops,
+  )
+  for (const dirName of [
+    CIPHERSTASH_V3_302_UPGRADE_MIGRATION_NAME,
+    CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME,
+  ]) {
+    await materialiseExtensionMigrationPackageIfMissing(
+      spaceDir,
+      descriptorPackage(dirName),
+    )
+  }
+}
+
+/**
+ * The CLI's phase-1 seed, reproduced from its two public primitives —
+ * `runContractSpaceSeedPhase` itself is not on `@prisma-next/cli`'s
+ * exports map, and `materialiseExtensionMigrationPackageIfMissing`
+ * documents this exact mirroring for extension-package tests. Order and
+ * semantics match `contract-space-seed-phase.ts`: re-emit the framework-
+ * owned artefacts unconditionally, then materialise only MISSING
+ * packages.
+ */
+async function runSeedPhase(migrationsDir: string): Promise<readonly string[]> {
+  const space = descriptorSpace()
+  await emitContractSpaceArtefacts(migrationsDir, CIPHERSTASH_SPACE_ID, {
+    contract: space.contractJson,
+    contractDts: 'export {};\n',
+    headRef: space.headRef,
+  })
+  const spaceDir = spaceMigrationDirectory(migrationsDir, CIPHERSTASH_SPACE_ID)
+  const written: string[] = []
+  for (const pkg of space.migrations) {
+    const result = await materialiseExtensionMigrationPackageIfMissing(
+      spaceDir,
+      pkg,
+    )
+    if (result.written) written.push(pkg.dirName)
+  }
+  return written
+}
+
+async function applyPath(
+  migrationsDir: string,
+  marker: {
+    readonly hash: string | null
+    readonly invariants: readonly string[]
+  },
+) {
+  return computeExtensionSpaceApplyPath({
+    projectMigrationsDir: migrationsDir,
+    spaceId: CIPHERSTASH_SPACE_ID,
+    currentMarkerHash: marker.hash,
+    currentMarkerInvariants: marker.invariants,
+  })
+}
+
+function requireOk<T extends { kind: string }>(
+  outcome: T,
+): Extract<T, { kind: 'ok' }> {
+  if (outcome.kind !== 'ok') {
+    throw new Error(`expected an applicable path, got "${outcome.kind}"`)
+  }
+  return outcome as Extract<T, { kind: 'ok' }>
+}
+
+let migrationsDir: string
+let root: string
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'cipherstash-stale-vendored-'))
+  migrationsDir = join(root, 'migrations')
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+describe('stale vendored migrations/cipherstash/ (generated against 1.0.0)', () => {
+  it('the fixture IS the published 1.0.0 baseline — proved by its content hash', () => {
+    // Content addressing turns this into an exact-bytes claim: only the
+    // 1.0.0 artefact hashes to fc495f7f…. If this fails, the fixture is
+    // no longer the thing consumers have on disk and every assertion
+    // below is about a straw man.
+    const stale = buildStale100Baseline()
+    const { migrationHash: _stored, ...envelope } = stale.metadata
+    expect(computeMigrationHash(envelope, stale.ops)).toBe(
+      STALE_1_0_0_BASELINE_HASH,
+    )
+    // …and it is genuinely NOT what the package ships today.
+    expect(v3BaselineMetadata.migrationHash).not.toBe(STALE_1_0_0_BASELINE_HASH)
+    expect(v3BaselineMetadata.migrationHash).toBe(
+      'sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05',
+    )
+    // The stale bundle is pre-rename; the shipped one is post-rename.
+    const staleSql = stale.ops[0]?.execute[0]?.sql ?? ''
+    expect(staleSql).toContain('ste_vec_contains')
+    expect(staleSql).not.toContain('jsonb_document_contains')
+  })
+
+  it('HEADLINE: the seed phase keeps the stale baseline and reports no problem', async () => {
+    // This is the finding. `migrationHash` verifies a package against its
+    // OWN bytes, and the vendored 1.0.0 copy is internally intact — so it
+    // passes. The seed phase's by-existence skip never rewrites it and
+    // never compares it to the descriptor. The upgrade is therefore
+    // silent: no hash mismatch, no warning, no mention of the stale
+    // directory anywhere in the pipeline.
+    await vendorStale100Space(migrationsDir)
+    const newlyWritten = await runSeedPhase(migrationsDir)
+
+    // Only the 3.0.5 directory is new; the re-emitted baseline is NOT
+    // re-materialised over the stale copy.
+    expect(newlyWritten).toEqual([CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME])
+
+    const spaceDir = spaceMigrationDirectory(
+      migrationsDir,
+      CIPHERSTASH_SPACE_ID,
+    )
+    const onDiskBaseline = JSON.parse(
+      await readFile(
+        join(
+          spaceDir,
+          CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+          'migration.json',
+        ),
+        'utf8',
+      ),
+    ) as { migrationHash: string; providedInvariants: string[] }
+    expect(onDiskBaseline.migrationHash).toBe(STALE_1_0_0_BASELINE_HASH)
+    expect(onDiskBaseline.providedInvariants).toEqual([...INVARIANTS_1_0_0])
+
+    // The integrity checker's own load-time verdict: clean.
+    const { packages, problems } = await readMigrationsDir(spaceDir)
+    expect(problems).toEqual([])
+    expect(packages).toHaveLength(4)
+
+    // …while `refs/head.json` IS overwritten, unconditionally, and now
+    // demands an invariant the stale genesis edge does not provide. That
+    // asymmetry (head ref refreshed, packages frozen) is the whole
+    // failure mode.
+    const onDiskHead = JSON.parse(
+      await readFile(join(spaceDir, 'refs', 'head.json'), 'utf8'),
+    ) as { invariants: string[] }
+    expect(onDiskHead.invariants).toEqual([...headRef.invariants])
+    expect(onDiskHead.invariants).toContain(
+      CIPHERSTASH_V3_INVARIANTS.upgradeBundle305,
+    )
+  })
+
+  it('an existing 1.0.0 database still upgrades correctly — only the 3.0.5 edge runs', async () => {
+    // The changeset's claim: "Your database keeps its markers, so
+    // already-applied invariants are not re-run — the only new work is
+    // the 3.0.5 upgrade edge." Verified here for the consumer who did
+    // NOT delete the directory, which is the strictly harder case.
+    await vendorStale100Space(migrationsDir)
+    await runSeedPhase(migrationsDir)
+
+    const outcome = requireOk(
+      await applyPath(migrationsDir, {
+        hash: headRef.hash,
+        invariants: [...INVARIANTS_1_0_0],
+      }),
+    )
+    expect(outcome.walkedMigrationDirs).toEqual([
+      CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME,
+    ])
+    expect(outcome.providedInvariants).toEqual([
+      CIPHERSTASH_V3_INVARIANTS.upgradeBundle305,
+    ])
+    // The baseline is NOT re-run, so no marker-recorded invariant is
+    // re-applied and the stale bundle is never re-installed over 3.0.5.
+    const ops = asSqlOps(outcome.pathOps)
+    expect(ops.map((op) => op.id)).toEqual([
+      'cipherstash.upgrade-eql-v3-bundle-3.0.5',
+    ])
+    expect(ops[0]?.execute[0]?.sql).toContain('eql_v3.jsonb_document_contains')
+  })
+
+  it('…and identically for a consumer who DID follow the instruction', async () => {
+    // Deleting `migrations/cipherstash/` and re-running `migration plan`
+    // regenerates the directory from the descriptor. For an existing
+    // database the plan is the same single edge — so following the
+    // instruction costs nothing and changes nothing here. The difference
+    // only shows up on a fresh database (next two tests).
+    await runSeedPhase(migrationsDir)
+    const outcome = requireOk(
+      await applyPath(migrationsDir, {
+        hash: headRef.hash,
+        invariants: [...INVARIANTS_1_0_0],
+      }),
+    )
+    expect(outcome.walkedMigrationDirs).toEqual([
+      CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME,
+    ])
+  })
+
+  it('an already-3.0.5 database is a no-op — the upgrade edge does not re-run', async () => {
+    await runSeedPhase(migrationsDir)
+    const outcome = requireOk(
+      await applyPath(migrationsDir, {
+        hash: headRef.hash,
+        invariants: [...headRef.invariants],
+      }),
+    )
+    expect(outcome.walkedMigrationDirs).toEqual([])
+    expect(outcome.pathOps).toEqual([])
+  })
+})
+
+describe('fresh database: both install paths must converge on eql-3.0.5', () => {
+  it('a clean vendored space installs 3.0.5 from the genesis edge alone', async () => {
+    await runSeedPhase(migrationsDir)
+    const outcome = requireOk(
+      await applyPath(migrationsDir, { hash: null, invariants: [] }),
+    )
+    expect(outcome.walkedMigrationDirs).toEqual([
+      CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+    ])
+    expect(outcome.providedInvariants).toEqual([...headRef.invariants].sort())
+
+    const ops = asSqlOps(outcome.pathOps)
+    expect(ops[0]?.execute[0]?.sql).toContain('eql_v3.jsonb_document_contains')
+    // Every op additive, so `db init`'s additive-only policy accepts it.
+    expect(opsRefusedByDbInitPolicy(ops)).toEqual([])
+  })
+
+  it('a STALE vendored space still converges on 3.0.5 under `migrate` — but installs the bundle twice', async () => {
+    // `prisma-next migrate` allows every operation class, so it can walk
+    // the data-classed 3.0.5 self-edge. The end state is correct; the
+    // cost is that the stale genesis edge installs eql-3.0.4 first and
+    // the upgrade edge immediately re-installs eql-3.0.5 over it (the
+    // bundle SQL is re-install-safe, which is what makes this survivable
+    // rather than broken).
+    await vendorStale100Space(migrationsDir)
+    await runSeedPhase(migrationsDir)
+
+    const outcome = requireOk(
+      await applyPath(migrationsDir, { hash: null, invariants: [] }),
+    )
+    expect(outcome.walkedMigrationDirs).toEqual([
+      CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+      CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME,
+    ])
+    expect(outcome.providedInvariants).toEqual([...headRef.invariants].sort())
+
+    const ops = asSqlOps(outcome.pathOps)
+    const bundleSql = ops
+      .flatMap((op) => op.execute.map((step) => step.sql))
+      .filter((sql) => sql.length > 0)
+    expect(bundleSql).toHaveLength(2)
+    expect(bundleSql[0]).toContain('ste_vec_contains')
+    expect(bundleSql[1]).toContain('eql_v3.jsonb_document_contains')
+  })
+
+  it('DEFECT: a STALE vendored space breaks `db init`, and the refusal never names the stale directory', async () => {
+    // `db init` runs additive-only. The stale genesis edge provides three
+    // of the four head-ref invariants, so the planner has to reach for the
+    // data-classed 3.0.5 self-edge — and the runner then refuses the run
+    // with a POLICY_VIOLATION naming only an operation id.
+    //
+    // Pinned because it is the one path where ignoring the changeset's
+    // "Action required" note actually fails, and because the message a
+    // consumer sees is UNRELATED to the cause: nothing in it mentions the
+    // vendored directory, the baseline re-emit, or the remedy. There is
+    // no in-package lever to improve it — the text is produced by
+    // `@prisma-next/target-postgres`'s `enforcePolicyCompatibility`, and
+    // the operation id it interpolates is frozen inside a published,
+    // content-addressed artefact. If this test starts failing because a
+    // framework upgrade made the refusal self-describing, delete it.
+    await vendorStale100Space(migrationsDir)
+    await runSeedPhase(migrationsDir)
+
+    const outcome = requireOk(
+      await applyPath(migrationsDir, { hash: null, invariants: [] }),
+    )
+    const ops = asSqlOps(outcome.pathOps)
+    expect(opsRefusedByDbInitPolicy(ops)).toEqual([
+      'cipherstash.upgrade-eql-v3-bundle-3.0.5',
+    ])
+
+    // The exact refusal the user reads, reconstructed from the target's
+    // template. It names an op id and a class; it does not name the
+    // problem or the remedy.
+    const refused = ops.find((op) => op.operationClass !== 'additive')
+    const message = `Operation ${refused?.id} has class "${refused?.operationClass}" which is not allowed by policy.`
+    expect(message).toBe(
+      'Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is not allowed by policy.',
+    )
+    expect(message).not.toContain('migrations/cipherstash')
+    expect(message).not.toContain('migration plan')
+
+    // Since the message cannot be improved from inside this package, the
+    // README — which ships in the npm tarball — has to carry the bridge
+    // from that exact string to the remedy. Pinned so the two cannot
+    // drift apart: a user's only route from the error to the fix is
+    // pasting it into a search.
+    const readme = await readFile(
+      join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'README.md'),
+      'utf8',
+    )
+    expect(readme).toContain(message)
+    expect(readme).toContain('rm -rf migrations/cipherstash')
+    expect(readme).toContain('prisma-next migration plan')
+  })
+
+  it('the same fresh `db init` succeeds once the instruction is followed', async () => {
+    // Deleting the directory and re-running the seed phase is the whole
+    // remedy: the regenerated genesis edge carries all four invariants as
+    // additive ops, so nothing outside the policy is ever planned.
+    await vendorStale100Space(migrationsDir)
+    await rm(spaceMigrationDirectory(migrationsDir, CIPHERSTASH_SPACE_ID), {
+      recursive: true,
+      force: true,
+    })
+    await runSeedPhase(migrationsDir)
+
+    const outcome = requireOk(
+      await applyPath(migrationsDir, { hash: null, invariants: [] }),
+    )
+    const ops = asSqlOps(outcome.pathOps)
+    expect(opsRefusedByDbInitPolicy(ops)).toEqual([])
+    expect(outcome.walkedMigrationDirs).toEqual([
+      CIPHERSTASH_V3_BASELINE_MIGRATION_NAME,
+    ])
+  })
+})
+
+/**
+ * The seed phase runs from ONE command. `runContractSpaceSeedPhase` is
+ * called only by `prisma-next migration plan`
+ * (`@prisma-next/cli/src/commands/migration-plan.ts`); `migrate`,
+ * `db init` and `db update` plan straight from whatever is on disk. So a
+ * consumer who upgrades the package and runs `migrate` — without a
+ * `migration plan` first — never materialises the 3.0.5 directory and
+ * never re-pins `refs/head.json`.
+ *
+ * This is not specific to the 3.0.5 re-emit (it was equally true of the
+ * append-only 3.0.2 and 3.0.4 bumps), but it IS the shape the changeset's
+ * "re-install through this edge on the next `prisma-next migrate`"
+ * sentence gets wrong, and it is the only path in this whole area that
+ * fails silently rather than loudly.
+ */
+describe('no seed phase run: the 3.0.5 upgrade is silently invisible', () => {
+  it('`migrate` against an existing 1.0.0 database is a no-op — 3.0.5 never applies', async () => {
+    await vendorStale100Space(migrationsDir)
+    // deliberately NO runSeedPhase — the user ran `migrate`, not `plan`
+
+    const outcome = requireOk(
+      await applyPath(migrationsDir, {
+        hash: headRef.hash,
+        invariants: [...INVARIANTS_1_0_0],
+      }),
+    )
+    // No error, no warning, no work: the on-disk head ref still demands
+    // only the three 1.0.0 invariants, which the marker already has.
+    expect(outcome.walkedMigrationDirs).toEqual([])
+    expect(outcome.pathOps).toEqual([])
+    expect(outcome.contractSpaceHeadRef.invariants).not.toContain(
+      CIPHERSTASH_V3_INVARIANTS.upgradeBundle305,
+    )
+  })
+
+  it('`db init` against a fresh database silently installs eql-3.0.4', async () => {
+    await vendorStale100Space(migrationsDir)
+    // deliberately NO runSeedPhase
+
+    const outcome = requireOk(
+      await applyPath(migrationsDir, { hash: null, invariants: [] }),
+    )
+    const ops = asSqlOps(outcome.pathOps)
+    // Succeeds — every op is additive, so `db init`'s policy is happy…
+    expect(opsRefusedByDbInitPolicy(ops)).toEqual([])
+    // …and the database lands on the PREVIOUS bundle, with the marker
+    // recording three invariants rather than four.
+    expect(ops[0]?.execute[0]?.sql).toContain('ste_vec_contains')
+    expect(ops[0]?.execute[0]?.sql).not.toContain('jsonb_document_contains')
+    expect(outcome.providedInvariants).toEqual([...INVARIANTS_1_0_0].sort())
+  })
+})

From a4cadd2db73fd0d55ebb0631a8aa7ea7c454f915 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:27:20 +1000
Subject: [PATCH 14/20] fix(deps): four security overrides had been overtaken
 by their own fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Six open Dependabot alerts, all reachable because the overrides written to
close earlier ones had gone stale in two distinct ways.

OVERTAKEN SELECTORS go quiet. `postcss@<8.5.10` stopped matching once the
tree resolved 8.5.14, so the entry sat here looking like a fix while a
vulnerable version installed underneath it (#167 GHSA-r28c-9q8g-f849 HIGH,
path traversal reading arbitrary .map files via attacker-controlled
sourceMappingURL; #176 its incomplete-fix follow-up). `js-yaml@<3.15.0` was
overtaken by its own fix — the tree resolved exactly 3.15.0, so nothing
matched and nothing lifted it to 3.15.1 (#189).

EXACT PINS INSIDE A STILL-MATCHING RANGE are worse: they cannot self-heal
and Dependabot cannot fix them. `js-yaml@>=4.0.0 <5` kept matching, so a
pin written to FIX an advisory was holding the tree at 4.2.0 and blocking
4.3.1 (#155, #188 — quadratic-CPU DoS via merge-key chains, then `!!omap`
duplicate-key detection). `fast-uri@<3.1.3` did the same at 3.1.3 while
#158 needs 3.1.4 and #175 needs 3.1.5.

Both shapes are now written into the comments, because the lesson is
reusable: keep the ceiling AHEAD of the patched floor rather than at it.

THE js-yaml CAUTION IS DISCHARGED, checked rather than assumed. The
comment warned that a past bump broke changesets. @changesets/parse@0.4.3
declares `js-yaml: ^4.1.1`, which 4.3.1 satisfies; 4.2.0 and 4.3.1 have
identical `dependencies` and `exports`, no `engines`, no `main`; 4.3.0 and
4.3.1 are security backports only, with no API removal on the 4.x line —
the breaking churn (grouped constant exports, MERGE_KEY removal, mandatory
identify) is all on 5.x, which the `<5` ceiling already excludes. Verified
by resolving js-yaml from @changesets/parse's own path (4.3.1, not a nested
copy) and running `changeset status`, which parsed all 14 changesets and
produced the correct per-package bumps.

No cooldown bypass was needed: every target is 13-19 days old against the
7-day minimumReleaseAge. The comment claiming "4.3.0 is still inside the
cooldown" was 54 days stale.

None of the four is a runtime dependency of any published package, so
nothing ships them and this needs no changeset.

Also corrects dependabot.yml's "the only Rust in the repo" — there are two
cargo entries, and the /packages/eql one landed with the subtree.
---
 .github/dependabot.yml |  2 +-
 pnpm-lock.yaml         | 92 +++++++++++++++++++++---------------------
 pnpm-workspace.yaml    | 62 +++++++++++++++++++++-------
 3 files changed, 94 insertions(+), 62 deletions(-)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index bd1c83c0d..a4bdb9370 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -62,7 +62,7 @@ updates:
         update-types:
           - version-update:semver-major
 
-  # ── Cargo (packages/protect-ffi — the only Rust in the repo) ────
+  # ── Cargo (packages/protect-ffi — one of two Rust workspaces) ───
   # Absorbing protect-ffi brought a 494-crate Cargo.lock in-tree. osv-scanner
   # already sees it — `--recursive ./` walks the tree and extracts every
   # lockfile it recognises — so known advisories were visible from day one, but
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9c5979dfa..50110309a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -54,12 +54,12 @@ overrides:
   next@<15.5.18: ~15.5.18
   lodash@<4.18.0: ^4.18.0
   js-cookie@<3.0.7: ^3.0.7
-  postcss@<8.5.10: ^8.5.10
+  postcss@<8.5.26: ^8.5.26
   vite@>=7.0.0 <7.3.5: ~7.3.5
   esbuild@>=0.27.3 <0.28.1: ^0.28.1
-  js-yaml@<3.15.0: 3.15.0
-  js-yaml@>=4.0.0 <5: 4.2.0
-  fast-uri@<3.1.3: 3.1.3
+  js-yaml@<3.15.1: 3.15.1
+  js-yaml@>=4.0.0 <5: 4.3.1
+  fast-uri@<3.1.5: 3.1.5
 
 importers:
 
@@ -75,8 +75,8 @@ importers:
         specifier: ^22.20.1
         version: 22.20.1
       js-yaml:
-        specifier: 4.2.0
-        version: 4.2.0
+        specifier: 4.3.1
+        version: 4.3.1
       rimraf:
         specifier: ^6.1.3
         version: 6.1.3
@@ -290,7 +290,7 @@ importers:
         version: 7.2.0
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       tsx:
         specifier: catalog:repo
         version: 4.23.0
@@ -327,7 +327,7 @@ importers:
         version: 22.20.1
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       typescript:
         specifier: catalog:repo
         version: 5.9.3
@@ -355,7 +355,7 @@ importers:
         version: 8.22.0
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       typescript:
         specifier: catalog:repo
         version: 5.9.3
@@ -380,7 +380,7 @@ importers:
         version: 15.5.21(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       typescript:
         specifier: catalog:repo
         version: 5.9.3
@@ -516,7 +516,7 @@ importers:
         version: 3.4.9
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       tsx:
         specifier: catalog:repo
         version: 4.23.0
@@ -575,7 +575,7 @@ importers:
         version: 3.4.9
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       typescript:
         specifier: catalog:repo
         version: 5.9.3
@@ -669,7 +669,7 @@ importers:
         version: 3.4.9
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       typescript:
         specifier: catalog:repo
         version: 5.9.3
@@ -715,7 +715,7 @@ importers:
         version: 3.4.9
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       typescript:
         specifier: catalog:repo
         version: 5.9.3
@@ -774,7 +774,7 @@ importers:
         version: 8.20.0
       tsup:
         specifier: catalog:repo
-        version: 8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
+        version: 8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0)
       tsx:
         specifier: catalog:repo
         version: 4.23.0
@@ -2692,8 +2692,8 @@ packages:
   fast-string-width@3.0.2:
     resolution: {integrity: sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==}
 
-  fast-uri@3.1.3:
-    resolution: {integrity: sha512-i70LwGWUduXqzicKXWshooq+sWL1K3WUU5rKZNG/0i3a1OSoX3HqhH5WbWwTmqWfor4urUakGPiRQcleRZTwOg==}
+  fast-uri@3.1.5:
+    resolution: {integrity: sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==}
 
   fast-wrap-ansi@0.2.0:
     resolution: {integrity: sha512-rLV8JHxTyhVmFYhBJuMujcrHqOT2cnO5Zxj37qROj23CP39GXubJRBUFF0z8KFK77Uc0SukZUf7JZhsVEQ6n8w==}
@@ -2924,12 +2924,12 @@ packages:
   js-tokens@9.0.1:
     resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
 
-  js-yaml@3.15.0:
-    resolution: {integrity: sha512-ttBQIIQPDeLjpPOohtUdXuXUVoA2uIB6fEH9HyJ7234s5mBJ5wTx20njxplLZQgLaOfpmPQA7X2t5AX6tIPbog==}
+  js-yaml@3.15.1:
+    resolution: {integrity: sha512-S99WuO3HlhO3XN41EtYUNl9zzXjoJx7QvmipxsJVxtCBT0YHEFy+iOJhjSvrmV12nYhWpZaM8lPHkJm0yUMbag==}
     hasBin: true
 
-  js-yaml@4.2.0:
-    resolution: {integrity: sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==}
+  js-yaml@4.3.1:
+    resolution: {integrity: sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ==}
     hasBin: true
 
   json-schema-to-ts@3.1.1:
@@ -3125,8 +3125,8 @@ packages:
     resolution: {integrity: sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==}
     engines: {node: '>=8.0.0'}
 
-  nanoid@3.3.12:
-    resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==}
+  nanoid@3.3.18:
+    resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
@@ -3333,7 +3333,7 @@ packages:
     engines: {node: '>= 18'}
     peerDependencies:
       jiti: '>=1.21.0'
-      postcss: ^8.5.10
+      postcss: ^8.5.26
       tsx: ^4.8.1
       yaml: ^2.4.2
     peerDependenciesMeta:
@@ -3346,8 +3346,8 @@ packages:
       yaml:
         optional: true
 
-  postcss@8.5.14:
-    resolution: {integrity: sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==}
+  postcss@8.5.26:
+    resolution: {integrity: sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==}
     engines: {node: ^10 || ^12 || >=14}
 
   postgres-array@2.0.0:
@@ -3706,7 +3706,7 @@ packages:
     peerDependencies:
       '@microsoft/api-extractor': ^7.36.0
       '@swc/core': ^1
-      postcss: ^8.5.10
+      postcss: ^8.5.26
       typescript: '>=4.5.0'
     peerDependenciesMeta:
       '@microsoft/api-extractor':
@@ -3957,7 +3957,7 @@ snapshots:
     dependencies:
       '@jsdevtools/ono': 7.1.3
       '@types/json-schema': 7.0.15
-      js-yaml: 4.2.0
+      js-yaml: 4.3.1
 
   '@ark/schema@0.56.2':
     dependencies:
@@ -4146,7 +4146,7 @@ snapshots:
   '@changesets/parse@0.4.3':
     dependencies:
       '@changesets/types': 6.1.0
-      js-yaml: 4.2.0
+      js-yaml: 4.3.1
 
   '@changesets/pre@2.0.2':
     dependencies:
@@ -5259,7 +5259,7 @@ snapshots:
   ajv@8.20.0:
     dependencies:
       fast-deep-equal: 3.1.3
-      fast-uri: 3.1.3
+      fast-uri: 3.1.5
       json-schema-traverse: 1.0.0
       require-from-string: 2.0.2
 
@@ -5627,7 +5627,7 @@ snapshots:
     dependencies:
       fast-string-truncated-width: 3.0.3
 
-  fast-uri@3.1.3: {}
+  fast-uri@3.1.5: {}
 
   fast-wrap-ansi@0.2.0:
     dependencies:
@@ -5843,12 +5843,12 @@ snapshots:
 
   js-tokens@9.0.1: {}
 
-  js-yaml@3.15.0:
+  js-yaml@3.15.1:
     dependencies:
       argparse: 1.0.10
       esprima: 4.0.1
 
-  js-yaml@4.2.0:
+  js-yaml@4.3.1:
     dependencies:
       argparse: 2.0.1
 
@@ -5863,7 +5863,7 @@ snapshots:
       '@types/json-schema': 7.0.15
       '@types/lodash': 4.17.21
       is-glob: 4.0.3
-      js-yaml: 4.2.0
+      js-yaml: 4.3.1
       lodash: 4.18.1
       minimist: 1.2.8
       prettier: 3.7.4
@@ -6019,7 +6019,7 @@ snapshots:
       lru.min: 1.1.4
     optional: true
 
-  nanoid@3.3.12: {}
+  nanoid@3.3.18: {}
 
   negotiator@1.0.0: {}
 
@@ -6028,7 +6028,7 @@ snapshots:
       '@next/env': 15.5.21
       '@swc/helpers': 0.5.15
       caniuse-lite: 1.0.30001760
-      postcss: 8.5.14
+      postcss: 8.5.26
       react: 19.2.3
       react-dom: 19.2.3(react@19.2.3)
       styled-jsx: 5.1.6(react@19.2.3)
@@ -6187,18 +6187,18 @@ snapshots:
 
   pluralize@8.0.0: {}
 
-  postcss-load-config@6.0.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(yaml@2.9.0):
+  postcss-load-config@6.0.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(yaml@2.9.0):
     dependencies:
       lilconfig: 3.1.3
     optionalDependencies:
       jiti: 2.7.0
-      postcss: 8.5.14
+      postcss: 8.5.26
       tsx: 4.23.0
       yaml: 2.9.0
 
-  postcss@8.5.14:
+  postcss@8.5.26:
     dependencies:
-      nanoid: 3.3.12
+      nanoid: 3.3.18
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
@@ -6268,7 +6268,7 @@ snapshots:
   read-yaml-file@1.1.0:
     dependencies:
       graceful-fs: 4.2.11
-      js-yaml: 3.15.0
+      js-yaml: 3.15.1
       pify: 4.0.1
       strip-bom: 3.0.0
 
@@ -6573,7 +6573,7 @@ snapshots:
 
   tslib@2.8.1: {}
 
-  tsup@8.5.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0):
+  tsup@8.5.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(typescript@5.9.3)(yaml@2.9.0):
     dependencies:
       bundle-require: 5.1.0(esbuild@0.28.1)
       cac: 6.7.14
@@ -6584,7 +6584,7 @@ snapshots:
       fix-dts-default-cjs-exports: 1.0.1
       joycon: 3.1.1
       picocolors: 1.1.1
-      postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.14)(tsx@4.23.0)(yaml@2.9.0)
+      postcss-load-config: 6.0.1(jiti@2.7.0)(postcss@8.5.26)(tsx@4.23.0)(yaml@2.9.0)
       resolve-from: 5.0.0
       rollup: 4.60.4
       source-map: 0.7.6
@@ -6593,7 +6593,7 @@ snapshots:
       tinyglobby: 0.2.16
       tree-kill: 1.2.2
     optionalDependencies:
-      postcss: 8.5.14
+      postcss: 8.5.26
       typescript: 5.9.3
     transitivePeerDependencies:
       - jiti
@@ -6694,7 +6694,7 @@ snapshots:
       esbuild: 0.28.1
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
-      postcss: 8.5.14
+      postcss: 8.5.26
       rollup: 4.60.4
       tinyglobby: 0.2.16
     optionalDependencies:
@@ -6711,7 +6711,7 @@ snapshots:
       esbuild: 0.28.1
       fdir: 6.5.0(picomatch@4.0.4)
       picomatch: 4.0.4
-      postcss: 8.5.14
+      postcss: 8.5.26
       rollup: 4.60.4
       tinyglobby: 0.2.16
     optionalDependencies:
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 051d7bcdd..a8b7d9ef7 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -66,7 +66,16 @@ overrides:
   # #133 GHSA-qjx8-664m-686j — js-cookie attribute injection
   'js-cookie@<3.0.7': '^3.0.7'
   # #102 GHSA-qx2v-qp2m-jg93 — postcss XSS via unescaped </style>
-  'postcss@<8.5.10': '^8.5.10'
+  # #167 GHSA-r28c-9q8g-f849 / CVE-2026-73646 (HIGH) — path traversal reading
+  # arbitrary .map files via attacker-controlled sourceMappingURL when `from`
+  # is unset. #176 GHSA-fxqj-rqcc-2cmp / CVE-2026-69153 is its incomplete-fix
+  # follow-up (patched 8.5.23).
+  #
+  # THE SELECTOR IS THE LESSON. `postcss@<8.5.10` stopped matching once the tree
+  # resolved 8.5.14, so the override went inert and a vulnerable version
+  # installed with the entry still sitting here looking like a fix. Keep the
+  # ceiling AHEAD of the patched floor, not at it.
+  'postcss@<8.5.26': '^8.5.26'
   # #145 GHSA-fx2h-pf6j-xcff, #146 GHSA-v6wh-96g9-6wx3 — vite dev server (Windows)
   'vite@>=7.0.0 <7.3.5': '~7.3.5'
   # #142 GHSA-g7r4-m6w7-qqqr — esbuild dev server. 0.28.1 is the FIRST patched
@@ -75,22 +84,45 @@ overrides:
   # declares ^0.28.
   'esbuild@>=0.27.3 <0.28.1': '^0.28.1'
   # #153 GHSA-h67p-54hq-rp68 / CVE-2026-53550 — js-yaml merge-key DoS, 3.x line.
-  # Exact pin: 3.15.0 is the only patched 3.x release. Installed with the
-  # one-off `--config.minimum-release-age=0` bypass (published 2026-06-26,
-  # matures 2026-07-04) per SKILL.md, instead of a minimumReleaseAgeExclude
-  # entry.
-  'js-yaml@<3.15.0': '3.15.0'
+  # #189 GHSA-5p4m-2wfm-xmqj / CVE-2026-59870 (HIGH) — quadratic-CPU DoS in
+  # `!!omap` duplicate-key detection; patched in 3.15.1.
+  #
+  # The previous `<3.15.0` selector had been overtaken by its own fix: the tree
+  # resolved exactly 3.15.0, so nothing matched and nothing lifted it to 3.15.1.
+  # Reached only through `read-yaml-file`.
+  'js-yaml@<3.15.1': '3.15.1'
   # #152 GHSA-h67p-54hq-rp68 / CVE-2026-53550 — js-yaml merge-key DoS, 4.x line.
-  # Exact-pinned to the MATURED 4.2.0 (4.3.0 is still inside the cooldown), and
-  # kept exact because a past js-yaml upgrade broke changesets — bump this
-  # deliberately and re-verify `changeset status`/`version` when you do.
-  'js-yaml@>=4.0.0 <5': '4.2.0'
-  # Not a Dependabot alert — cooldown-regression guard. Re-resolving the
-  # lockfile let minimumReleaseAge demote ajv's fast-uri to 3.1.2, un-fixing
+  # #155 GHSA-52cp-r559-cp3m / CVE-2026-59869 (HIGH, patched 4.3.0) and
+  # #188 GHSA-5p4m-2wfm-xmqj / CVE-2026-59870 (HIGH, patched 4.3.1).
+  #
+  # THIS ENTRY WAS ENFORCING THE VULNERABILITY. Unlike the two overtaken
+  # selectors above, `>=4.0.0 <5` kept matching — so an exact pin written to FIX
+  # an advisory was holding the tree at 4.2.0 and blocking 4.3.1. An exact pin
+  # inside a still-matching range is the worst of the three shapes: it cannot
+  # self-heal and it cannot be fixed by Dependabot.
+  #
+  # The "a past js-yaml upgrade broke changesets" caution is DISCHARGED for this
+  # bump, checked rather than assumed: @changesets/parse declares
+  # `js-yaml: ^4.1.1`, which 4.3.1 satisfies; 4.2.0 and 4.3.1 have identical
+  # `dependencies` (argparse ^2.0.1) and `exports`, no `engines`, no `main`;
+  # 4.3.0/4.3.1 are security backports only (a `maxTotalMergeKeys` loader option
+  # and the `!!omap` fix), with no API removal on the 4.x line. The breaking
+  # churn — grouped constant exports, `MERGE_KEY` removal, mandatory `identify`
+  # — is all on 5.x, which the `<5` ceiling already excludes. Verified after the
+  # bump with `changeset status` and a `changeset version` dry run.
+  #
+  # Kept exact so a future 4.x regression cannot arrive silently; the ceiling
+  # stays `<5`. Consumers: @changesets/parse and json-schema-to-typescript.
+  'js-yaml@>=4.0.0 <5': '4.3.1'
+  # Cooldown-regression guard AND two live advisories. Re-resolving the lockfile
+  # let minimumReleaseAge demote ajv's fast-uri to 3.1.2, un-fixing
   # GHSA-4c8g-83qw-93j6 / CVE-2026-13676 (host confusion via failed IDN
-  # canonicalization). Pin the patched release (published 2026-06-29, matures
-  # 2026-07-06); safe to relax to ^3.1.3 after that date.
-  'fast-uri@<3.1.3': '3.1.3'
+  # canonicalization) — hence a pin rather than a floor.
+  #
+  # But 3.1.3 was itself overtaken: #158 (HIGH) needs 3.1.4 and #175 (HIGH)
+  # needs 3.1.5, so the exact pin was enforcing a vulnerable version — the same
+  # shape as the js-yaml 4.x entry above. Reached through ajv.
+  'fast-uri@<3.1.5': '3.1.5'
 
 # Supply-chain hardening — see skills/stash-supply-chain-security/
 # 7 days in minutes; mirrors the Dependabot cooldown so manual + automated

From 10fca72ba91c0f7b1a908e3f2334820070e839d4 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:36:24 +1000
Subject: [PATCH 15/20] fix(biome): align the config schema with the version
 actually installed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`biome.json` declared schema 2.5.2 while `package.json` has required
`^2.5.3` and the lockfile has resolved 2.5.3 since before this branch —
so `biome check` exits 1 with "The configuration schema version does not
match the CLI version 2.5.3", and `code:check` fails for a reason unrelated
to any code in the tree.

It stayed hidden because node_modules on this machine still held 2.5.2; a
`pnpm install` that brings the tree in line with its own lockfile is what
surfaces it, which is exactly what CI does on every run.
---
 biome.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/biome.json b/biome.json
index 987de3c3d..4e94394bc 100644
--- a/biome.json
+++ b/biome.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.5.2/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.3/schema.json",
   "files": {
     "includes": [
       "**",

From 2a140e8434ead2a3de2bb950d1ca56c007d272b8 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 12:36:41 +1000
Subject: [PATCH 16/20] fix(eql): re-emit against the published 3.0.5, which
 kept the old name
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The subtree sync brought upstream's actual 3.0.5 release, and it is not the
bundle this branch had been carrying under that number. Upstream 142f41d8
restored `eql_v3.ste_vec_contains` as a deprecated delegating alias — both
overloads — and retargeted its own changeset from `major` to `patch` in the
same commit. The two decisions are one decision: it is a patch BECAUSE the
old name still resolves.

This branch had taken the other half of that trade — hard removal, still
shipped as a patch — so the tree held SQL stamped 3.0.5 that differed from
published 3.0.5 by 32 lines. That is the defect 9b1c44d9 exists to prevent,
one level up, and nothing would have caught it: `verify-release-assets.mjs`
compares the manifest's version to package.json and hashes nothing, and
`sync-generated.mjs` preserves `src/generated/release-manifest.ts` rather
than regenerating it, so `check:generated` is blind to it too.

The merge landed on upstream's bytes exactly — every artefact here now
hashes to `accde0030…`, the digest in the published tarball — so no
regeneration was needed beyond re-emitting the two prisma migrations that
bake the bundle.

ONLY TWO MIGRATIONS WERE RE-EMITTED, deliberately. All four `migration.ts`
files call `readVerifiedInstallSql()`, so re-running the 3.0.2 and 3.0.4
edges would silently bake 3.0.5 SQL into artefacts describing historical
releases. Looping over the directory is the obvious thing to do and it is
wrong; the frozen-digest test catches it, but only after the damage.

The one assertion whose MEANING changed is
`not.toContain('ste_vec_contains')`. Re-pinning it would have been wrong in
both directions, so it now asserts the SHAPE the alias has to take: exactly
two definitions, every body delegating to the new name rather than copying
the implementation, and both marked deprecated with `COMMENT ON FUNCTION`
so a DBA reading the schema sees it — not only the generated docs.

Everything else that moved is prose that had inverted. The upgrade note was
the worst of it: `v3.0.5.md` told readers to verify with a query commented
"Must return zero rows" against `proname = 'ste_vec_contains'`, which now
returns two — a reader following it would conclude the upgrade had failed.
The release is now genuinely non-breaking, which leaves U-002 (every EQL
install opens `DROP SCHEMA … CASCADE`) as the only item in it with
operational consequences.
---
 .changeset/eql-3-0-5-migration.md             | 18 ++---
 .../migration.json                            |  2 +-
 .../ops.json                                  |  2 +-
 .../migration.json                            |  2 +-
 .../ops.json                                  |  2 +-
 packages/eql/docs/upgrading/v3.0.5.md         | 72 ++++++++++---------
 packages/eql/packages/eql/CHANGELOG.md        | 40 +++++++----
 .../migration.json                            |  2 +-
 .../ops.json                                  |  2 +-
 .../migration.json                            |  2 +-
 .../migration.ts                              | 12 ++--
 .../ops.json                                  |  2 +-
 .../stack-prisma/test/v3/migration-v3.test.ts | 46 +++++++++---
 .../test/v3/stale-vendored-space.test.ts      | 11 ++-
 14 files changed, 135 insertions(+), 80 deletions(-)

diff --git a/.changeset/eql-3-0-5-migration.md b/.changeset/eql-3-0-5-migration.md
index 27479bed1..87688a540 100644
--- a/.changeset/eql-3-0-5-migration.md
+++ b/.changeset/eql-3-0-5-migration.md
@@ -14,12 +14,13 @@ are what a PostgREST caller invokes, so PostgREST callers on the documented
 surface are **not** affected. The renamed function is the typed implementation
 those operators dispatch into.
 
-**What does break is hand-written SQL naming the old function** — an
-application query, a view, an RLS policy, or a per-function
-`GRANT EXECUTE ON FUNCTION eql_v3.ste_vec_contains(…)`. After the upgrade
-those fail loudly (`function eql_v3.ste_vec_contains(…) does not exist`)
-rather than silently, but they fail. Grep your migrations, views and policies
-for `ste_vec_contains`.
+**And the old name still works.** eql-3.0.5 ships `eql_v3.ste_vec_contains` as
+a deprecated delegating alias for both overloads, so hand-written SQL naming it
+— an application query, a view, an RLS policy, or a per-function
+`GRANT EXECUTE ON FUNCTION eql_v3.ste_vec_contains(…)` — keeps resolving. The
+typed overload stays inlinable, so a function-form query through the alias
+still matches the same functional GIN index. Migrate to
+`jsonb_document_contains` when convenient; nothing forces it at upgrade time.
 
 **Separately — and true of every EQL upgrade, not just this one:** the install
 bundle opens with `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so applying it
@@ -27,8 +28,9 @@ destroys every grant on every object in `eql_v3` / `eql_v3_internal`, along
 with anything that depended on them (this is the same mechanism that drops
 functional indexes on encrypted columns). **Re-run your grant script after
 upgrading.** The schema-wide form EQL documents —
-`GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3 TO app_role` — picks the new
-name up on its own; a hand-written per-function grant has to be edited first.
+`GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3 TO app_role` — picks up both
+the new name and the alias on its own. **With the rename made non-breaking by
+the alias, this is the only part of the upgrade that needs action.**
 
 Two artefacts carry the new bundle:
 
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
index 4f472477d..230c7f589 100644
--- a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json
+++ b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/migration.json
@@ -8,5 +8,5 @@
     "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1"
   ],
   "createdAt": "2026-07-14T20:10:24.325Z",
-  "migrationHash": "sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05"
+  "migrationHash": "sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313"
 }
\ 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
index adc7748c5..d86ac25cf 100644
--- a/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json
+++ b/examples/prisma/migrations/cipherstash/20260601T0100_install_eql_v3_bundle/ops.json
@@ -11,7 +11,7 @@
     "execute": [
       {
         "description": "Install EQL v3 bundle (eql-3.0.5: 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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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"
+        "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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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": [
diff --git a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json
index 32e3cff6e..7c2a1d021 100644
--- a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json
+++ b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/migration.json
@@ -5,5 +5,5 @@
     "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1"
   ],
   "createdAt": "2026-08-14T00:45:14.365Z",
-  "migrationHash": "sha256:7bafd9d6c5d244332ff0b0943604dbd026c8369e24d2f335b1365c5f78e49d38"
+  "migrationHash": "sha256:3b2b838bee634f2de4a5e88f1625a45d47c327e3021b0e2ccba36c09a9666178"
 }
\ No newline at end of file
diff --git a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json
index 75c24c890..cc6bd650c 100644
--- a/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json
+++ b/examples/prisma/migrations/cipherstash/20260814T0000_upgrade_eql_v3_3_0_5/ops.json
@@ -11,7 +11,7 @@
     "execute": [
       {
         "description": "Upgrade EQL v3 bundle to eql-3.0.5",
-        "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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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"
+        "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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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": [
diff --git a/packages/eql/docs/upgrading/v3.0.5.md b/packages/eql/docs/upgrading/v3.0.5.md
index 874a44d14..d03887520 100644
--- a/packages/eql/docs/upgrading/v3.0.5.md
+++ b/packages/eql/docs/upgrading/v3.0.5.md
@@ -1,9 +1,10 @@
 # Upgrading to EQL 3.0.5
 
-`3.0.5` is a patch release carrying one rename in the public `eql_v3` surface.
-It is a patch, not a major, for the reason 3.0.1 was: a patch reaches every
-consumer already on a `^3.x` range at their next install, and the affected
-call site is one that almost nobody writes by hand.
+`3.0.5` is a patch release carrying one rename in the public `eql_v3` surface,
+with the old name retained as a deprecated alias. **Nothing in it requires you
+to change any SQL.** It is a patch, not a major, for the reason 3.0.1 was: a
+patch reaches every consumer already on a `^3.x` range at their next install —
+and with the alias in place there is no compatibility argument left to have.
 
 This guide also records a second thing, which is **not** new in 3.0.5 but bites
 hardest at upgrade time and has never had a note of its own: applying the EQL
@@ -12,8 +13,9 @@ survive it.
 
 ## TL;DR
 
-1. `eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains` —
-   [U-001](#u-001-the-containment-implementation-is-renamed).
+1. `eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`.
+   The old name still works — it is now a deprecated alias. Migrate at your
+   convenience — [U-001](#u-001-the-containment-implementation-is-renamed).
 2. Applying any EQL bundle destroys grants, indexes and dependent objects in
    `eql_v3` / `eql_v3_internal`; re-apply them afterwards —
    [U-002](#u-002-grants-and-dependent-objects-do-not-survive-an-install).
@@ -24,7 +26,7 @@ survive it.
 | --- | --- |
 | `@>` / `<@` on `public.eql_v3_json_search` | **Unchanged.** Same operators, same results, same index behaviour. |
 | `eql_v3.jsonb_contains(jsonb, jsonb)` / `eql_v3.jsonb_contained_by(jsonb, jsonb)` | **Unchanged**, byte for byte. These are the function-form entry points for platforms without operator support — PostgREST included — and they are not affected by this release. |
-| `eql_v3.ste_vec_contains` | **Renamed** to `eql_v3.jsonb_document_contains` (both overloads) — see U-001. |
+| `eql_v3.ste_vec_contains` | **Renamed** to `eql_v3.jsonb_document_contains` (both overloads), with the old name kept as a deprecated delegating alias — existing callers keep working. See U-001. |
 | `eql_v3.to_ste_vec_query`, `eql_v3.ste_vec`, `eql_v3.jsonb_array` | **Unchanged.** The documented GIN index recipe still reads `USING gin ((eql_v3.to_ste_vec_query(col)::jsonb) jsonb_path_ops)`. |
 | Wire format, domains, index terms | **Unchanged.** No re-encryption, no data migration. |
 
@@ -36,34 +38,35 @@ survive it.
 `eql_v3.jsonb_document_contains`, in both overloads —
 `(jsonb[], jsonb)` and
 `(public.eql_v3_json_search, public.eql_v3_json_search)`. The body is
-unchanged. The old name is **removed**; there is no compatibility alias.
+unchanged. **The old name is retained** as a deprecated alias for both
+overloads, each delegating to the new one — so this release breaks no caller.
 
 **Why.** It was the last object in the public surface still carrying
 `ste_vec_` naming, after the SteVec entry and query surface became
 `jsonb_entry` / `jsonb_query`. `ste_vec` is an implementation detail of the
 encrypted representation; the operator family it backs is the `jsonb_*` one.
 
-**Who is affected.** Only SQL that names the function directly. In particular
-this is **not** the PostgREST story it might look like: PostgREST calls
-functions rather than operators, but the function-form containment entry points
-it calls are `eql_v3.jsonb_contains` and `eql_v3.jsonb_contained_by`, and both
-are unchanged. `jsonb_document_contains` is what the typed `@>` / `<@`
-operators dispatch into.
+**Who is affected.** Nobody is forced to act. In particular this is **not** the
+PostgREST story it might look like: PostgREST calls functions rather than
+operators, but the function-form containment entry points it calls are
+`eql_v3.jsonb_contains` and `eql_v3.jsonb_contained_by`, and both are unchanged.
+`jsonb_document_contains` is what the typed `@>` / `<@` operators dispatch into.
 
-So the affected callers are hand-written:
+SQL that names the old function directly — application queries, views and
+matviews, RLS `USING` / `WITH CHECK` expressions, wrapping functions and
+triggers, and per-function `GRANT EXECUTE ON FUNCTION
+eql_v3.ste_vec_contains(…)` — all keep resolving, through the alias.
 
-- application queries, views or matviews naming `eql_v3.ste_vec_contains`
-- RLS policies whose `USING` / `WITH CHECK` expression names it
-- SQL functions or triggers that wrap it
-- a per-function grant, `GRANT EXECUTE ON FUNCTION eql_v3.ste_vec_contains(…)`
+The typed overload is deliberately `LANGUAGE sql` and stays inlinable, so a
+function-form query through the alias still matches the same functional GIN
+index it did before the rename. There is no performance cliff for not
+migrating.
 
-**What to do.** Grep your migrations, policies and application SQL for
-`ste_vec_contains` and replace it with `jsonb_document_contains`. Nothing else
-changes — same arguments, same return, same semantics. The failure is loud
-(`function eql_v3.ste_vec_contains(…) does not exist`), so an unfixed caller
-errors rather than silently returning the wrong rows; a view or policy is the
-case to check first, because the error surfaces at query time rather than at
-upgrade time.
+**What to do.** Nothing, to upgrade. When convenient, grep your migrations,
+policies and application SQL for `ste_vec_contains` and replace it with
+`jsonb_document_contains` — same arguments, same return, same semantics. The
+alias is marked deprecated in the database itself (`COMMENT ON FUNCTION`), so
+`\df+ eql_v3.ste_vec_contains` tells a DBA what to move to.
 
 **Verification.**
 
@@ -73,8 +76,8 @@ SELECT p.oid::regprocedure
 FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
 WHERE n.nspname = 'eql_v3' AND p.proname = 'jsonb_document_contains';
 
--- Must return zero rows:
-SELECT p.oid::regprocedure
+-- Must ALSO return two rows — the deprecated aliases, which 3.0.5 keeps:
+SELECT p.oid::regprocedure, obj_description(p.oid, 'pg_proc') AS note
 FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
 WHERE n.nspname = 'eql_v3' AND p.proname = 'ste_vec_contains';
 
@@ -147,11 +150,14 @@ WHERE indexdef LIKE '%eql_v3.%_term%' OR indexdef LIKE '%to_ste_vec_query%';
 
 ## Rollback
 
-U-001 is reversible by installing the 3.0.4 bundle, which restores the old
-function name. Nothing in the wire format or the stored data changes between
-3.0.4 and 3.0.5, so no re-encryption is involved in either direction — but note
-that rolling back re-runs the `DROP SCHEMA … CASCADE` in U-002, so grants and
-indexes need re-applying again afterwards.
+U-001 needs no rollback: 3.0.5 adds a name and keeps the old one, so anything
+that worked on 3.0.4 works on 3.0.5. Installing the 3.0.4 bundle does reverse
+it, and is the only way to remove `jsonb_document_contains` — but the reason to
+do so would have to come from somewhere other than this rename. Nothing in the
+wire format or the stored data changes between 3.0.4 and 3.0.5, so no
+re-encryption is involved in either direction — but note that rolling back
+re-runs the `DROP SCHEMA … CASCADE` in U-002, so grants and indexes need
+re-applying again afterwards.
 
 ## See also
 
diff --git a/packages/eql/packages/eql/CHANGELOG.md b/packages/eql/packages/eql/CHANGELOG.md
index 997bd20fd..1942b9676 100644
--- a/packages/eql/packages/eql/CHANGELOG.md
+++ b/packages/eql/packages/eql/CHANGELOG.md
@@ -10,24 +10,28 @@
   `jsonb_query`). The function backs the `json` `@>` / `<@` containment operators;
   its behaviour is unchanged.
 
-  **Who is affected is narrower than a rename usually implies.** The operators are
-  untouched, and so are the two function-form entry points a PostgREST deployment
-  actually calls — `eql_v3.jsonb_contains(jsonb, jsonb)` and
-  `eql_v3.jsonb_contained_by(jsonb, jsonb)` are byte-identical to 3.0.4. What
-  breaks is hand-written SQL that names `ste_vec_contains` directly: queries,
-  views, RLS policies, and per-function `GRANT`s. The schema-wide grant scripts in
-  `docs/reference/permissions.md` pick the new name up on their next run, and a
-  stale per-function grant fails loudly (`function … does not exist`) rather than
-  silently granting nothing. See [U-001](../../docs/upgrading/v3.0.5.md#u-001-the-containment-implementation-is-renamed),
-  and [U-002](../../docs/upgrading/v3.0.5.md#u-002-grants-and-dependent-objects-do-not-survive-an-install)
-  for the larger fact underneath it — the installer opens with
-  `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so *every* EQL install drops grants,
-  functional indexes and dependent views, not just this one.
+  **Nothing breaks.** The old name remains as a deprecated delegating alias, both
+  overloads, so direct callers keep working. The operators never moved, and
+  neither did the two function-form entry points a PostgREST deployment actually
+  calls — `eql_v3.jsonb_contains(jsonb, jsonb)` and
+  `eql_v3.jsonb_contained_by(jsonb, jsonb)` are byte-identical to 3.0.4. Hand-written
+  SQL naming `ste_vec_contains` — queries, views, RLS policies, per-function
+  `GRANT`s — continues to resolve; update it at your convenience, not under
+  pressure. See [U-001](../../docs/upgrading/v3.0.5.md#u-001-the-containment-implementation-is-renamed).
+
+  **The thing in this release that does have consequences is not the rename.**
+  The installer opens with `DROP SCHEMA IF EXISTS eql_v3 CASCADE`, so *every* EQL
+  install drops grants, functional indexes and dependent views — true of every
+  release, not just this one, and now the only item here with operational weight.
+  See [U-002](../../docs/upgrading/v3.0.5.md#u-002-grants-and-dependent-objects-do-not-survive-an-install).
 
   Released as a **patch**, matching 3.0.1, which shipped the fuzzy-match operator
   change (`@>` / `<@` → `@@`) at the same level. The parked changeset proposed
   `major`; a patch reaches every consumer already on a `^3.x` range at their next
-  install, which a major would not have done.
+  install, which a major would not have done — and with the alias in place the
+  patch level is not a judgement call at all. Upstream reached the same
+  conclusion independently, retargeting its own changeset from `major` to `patch`
+  in the commit that restored the aliases.
 
   Entered by hand rather than by `changeset version`. The rename landed in the
   tree with the monorepo import and was never released, so the package shipped
@@ -37,6 +41,14 @@
   the whole repository. The bump is therefore applied directly and
   `.changeset/rename-ste-vec-contains.md.deferred` is deleted with it, so the
   cutover cannot apply the same bump a second time.
+
+  The SQL that actually shipped is upstream's, not this tree's: `@cipherstash/eql@3.0.5`
+  was published from `cipherstash/encrypt-query-language` (the last release from
+  there) and carries the restored aliases from upstream `142f41d8`, which this
+  tree did not have when the entry above was first written. The subtree was
+  re-synced to that release so the bundle here is byte-identical to the published
+  one — `installSqlSha256: accde0030…`. The generated entry below is upstream's
+  own changeset for the same release.
 - 4c2bb92: **`eql_v3.ste_vec_contains` is renamed to `eql_v3.jsonb_document_contains`.** This
   consolidates the last `ste_vec_*`-named public object into the `jsonb_*` family,
   matching the earlier renames of the SteVec entry/query surface (`jsonb_entry`,
diff --git a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json
index 4f472477d..230c7f589 100644
--- a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json
+++ b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/migration.json
@@ -8,5 +8,5 @@
     "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1"
   ],
   "createdAt": "2026-07-14T20:10:24.325Z",
-  "migrationHash": "sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05"
+  "migrationHash": "sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313"
 }
\ No newline at end of file
diff --git a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json
index adc7748c5..d86ac25cf 100644
--- a/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json
+++ b/packages/stack-prisma/migrations/20260601T0100_install_eql_v3_bundle/ops.json
@@ -11,7 +11,7 @@
     "execute": [
       {
         "description": "Install EQL v3 bundle (eql-3.0.5: 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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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"
+        "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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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": [
diff --git a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json
index 32e3cff6e..7c2a1d021 100644
--- a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json
+++ b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.json
@@ -5,5 +5,5 @@
     "cipherstash:upgrade-eql-v3-bundle-3.0.5-v1"
   ],
   "createdAt": "2026-08-14T00:45:14.365Z",
-  "migrationHash": "sha256:7bafd9d6c5d244332ff0b0943604dbd026c8369e24d2f335b1365c5f78e49d38"
+  "migrationHash": "sha256:3b2b838bee634f2de4a5e88f1625a45d47c327e3021b0e2ccba36c09a9666178"
 }
\ No newline at end of file
diff --git a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts
index 1f0bef285..75b302b9e 100644
--- a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts
+++ b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/migration.ts
@@ -4,8 +4,9 @@
  *
  * 3.0.5 renames `eql_v3.ste_vec_contains` to `eql_v3.jsonb_document_contains`,
  * consolidating the last `ste_vec_*`-named public object into the `jsonb_*`
- * family. The operators are unchanged; only callers that invoke the function
- * by name (Supabase / PostgREST) are affected.
+ * family. Nothing breaks: the operators are unchanged, the PostgREST-facing
+ * `jsonb_contains` / `jsonb_contained_by` are unchanged, and the old name ships
+ * on as a deprecated delegating alias for both overloads.
  *
  * This is a separate invariant-only edge from the v3 baseline. A database
  * that already recorded the baseline (and/or 3.0.2 / 3.0.4) invariant must
@@ -76,9 +77,10 @@ export default class M extends Migration {
             sql: "SELECT to_regtype('eql_v3.query_json') IS NOT NULL",
           },
           {
-            // The rename this release carries: the old `ste_vec_contains`
-            // name is gone, so assert the new one is what the reinstall
-            // left behind.
+            // The rename this release carries. Asserts the NEW name exists,
+            // which is what distinguishes a 3.0.5 bundle from a 3.0.4 one —
+            // deliberately not "the old name is absent", since 3.0.5 keeps it
+            // as a deprecated alias and both names are present after this.
             description:
               'verify the renamed eql_v3.jsonb_document_contains 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 = 'jsonb_document_contains')",
diff --git a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json
index 75c24c890..cc6bd650c 100644
--- a/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json
+++ b/packages/stack-prisma/migrations/20260814T0000_upgrade_eql_v3_3_0_5/ops.json
@@ -11,7 +11,7 @@
     "execute": [
       {
         "description": "Upgrade EQL v3 bundle to eql-3.0.5",
-        "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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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"
+        "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/aggregates.sql\n--! @brief Aggregates for grouping and deduplicating encrypted values.\n--!\n--! Provides `eql_v3.grouped_value` — the aggregate you need to run a `GROUP BY`\n--! over an encrypted column and still get the encrypted value back.\n--!\n--! ## Grouping encrypted values\n--!\n--! Encryption in EQL is non-deterministic: encrypting the same value twice gives\n--! two different ciphertexts. So you cannot group rows by comparing the stored\n--! ciphertext. Instead you group by the column's *equality term*,\n--! `eql_v3.eq_term(col)` — a deterministic keyed hash that is identical for equal\n--! plaintexts. Counting how many rows share each encrypted value looks like this\n--! (the term itself is opaque, so there is no reason to select it):\n--!\n--!   SELECT count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! The equality term is opaque, though — you usually want the encrypted value\n--! itself back so your application can decrypt it. Adding the column to the\n--! SELECT list is rejected:\n--!\n--!   SELECT email, count(*)                        -- email is not in GROUP BY\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!   -- ERROR: column \"email\" must appear in the GROUP BY clause or be used in\n--!   --        an aggregate function\n--!\n--! Every row in a group is an encryption of the same plaintext, so any one of\n--! them represents the group. `eql_v3.grouped_value` is the aggregate that hands\n--! one back:\n--!\n--!   SELECT eql_v3.grouped_value(email) AS email, count(*)\n--!   FROM users\n--!   GROUP BY eql_v3.eq_term(email);\n--!\n--! ## Deduplicating without an aggregate\n--!\n--! If you just want the distinct encrypted values (no per-group aggregate like\n--! `count`), you do not need `grouped_value` — use `DISTINCT ON` on the equality\n--! term, which lets you project the column directly:\n--!\n--!   SELECT DISTINCT ON (eql_v3.eq_term(email)) email\n--!   FROM users\n--!   ORDER BY eql_v3.eq_term(email);\n--!\n--! Deduplicate on `eql_v3.eq_term(col)`, never on the column itself: a plain\n--! `SELECT DISTINCT email` compares the raw ciphertext, so two encryptions of the\n--! same value are NOT collapsed.\n--!\n--! @note @internal Hand-written rather than catalog-generated: `grouped_value` is\n--!   generic over every encrypted-domain type — each is a jsonb-backed domain, so\n--!   a single aggregate over `jsonb` accepts them all and returns the value\n--!   unchanged — unlike the per-type `min`/`max` aggregates. Re-creates the\n--!   eql_v2 aggregate of the same name.\n\n--! @brief State transition function for the grouped_value aggregate.\n--! @internal\n--!\n--! Returns the running state so the first value the aggregate sees in a group\n--! wins. Declared STRICT: PostgreSQL seeds the null initial state with the first\n--! non-null input (without calling this function) and skips subsequent nulls, so\n--! the aggregate resolves to the first non-null value in the group — the same\n--! result the eql_v2 `COALESCE($1, $2)` state function produced.\n--!\n--! Per the encrypted-domain footgun rules this is `LANGUAGE plpgsql` with a\n--! pinned `search_path`, matching the generated `min`/`max` state functions; an\n--! aggregate state function is never a predicate the planner could inline, but\n--! keeping the convention uniform avoids surprises.\n--!\n--! @param state jsonb Accumulated state (the first non-null value seen).\n--! @param value jsonb New value from the current row.\n--! @return jsonb The running state (first non-null value).\n--!\n--! @see eql_v3.grouped_value\nCREATE FUNCTION eql_v3_internal.grouped_value_sfunc(state jsonb, value jsonb)\nRETURNS jsonb\nLANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE\nSET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN state;\nEND;\n$$;\n\n--! @brief Return a representative (first non-null) encrypted value per group.\n--!\n--! Returns the first non-null value encountered within a `GROUP BY` group. Its\n--! primary use is projecting an encrypted column while grouping by that column's\n--! equality term (`GROUP BY eql_v3.eq_term(col)`), where PostgreSQL will not let\n--! you `SELECT col` directly — see the file header for the worked example.\n--! Accepts any eql_v3 encrypted-domain value (each is a jsonb-backed domain) and\n--! returns it unchanged, performing no decryption or comparison. `PARALLEL SAFE`\n--! with a combine function, so it works under partial/parallel aggregation on\n--! large `GROUP BY` workloads.\n--!\n--! @param input jsonb Encrypted values to aggregate.\n--! @return jsonb The first non-null value in the group.\n--!\n--! @note Which value is \"first\" is arbitrary in the absence of an ordering, and\n--!   is not deterministic under parallel aggregation. That is exactly what is\n--!   wanted for the group-by-eq_term case (every value in a group is an\n--!   encryption of the same plaintext, so any one represents the group) and it\n--!   matches the eql_v2 original.\n--!\n--! Group encrypted rows by encrypted equality and project the encrypted\n--! column. GROUP BY eql_v3.eq_term(...) groups by the HMAC equality term;\n--! grouped_value(...) returns a representative ciphertext for each group so\n--! PostgreSQL does not reject the bare column reference.\n--!\n--! @code{.sql}\n--! SELECT eql_v3.grouped_value(encrypted_foo) AS encrypted_foo,\n--!        count(*)\n--! FROM some_table\n--! GROUP BY eql_v3.eq_term(encrypted_foo);\n--! @endcode\n--!\n--! @see eql_v3_internal.grouped_value_sfunc\n--! @see eql_v3.eq_term\nCREATE AGGREGATE eql_v3.grouped_value(jsonb) (\n  sfunc = eql_v3_internal.grouped_value_sfunc,\n  stype = jsonb,\n  combinefunc = eql_v3_internal.grouped_value_sfunc,\n  parallel = safe\n);\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/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/json/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_search     — storage/root: an EQL envelope object ({i, v, ...}).\n--!   - public.eql_v3_json_entry — a single sv element (returned by `->`).\n--!   - eql_v3.query_json  — 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 — for an ordered (number/string) path entry only — a string\n--!         `op` ordering term. Value entries (value-inclusive selectors) and\n--!         non-orderable path entries (bool/null/object/array) are term-less\n--!         `{s, c}`: exact matching is selector presence, so an entry carries\n--!         no per-value equality term. `hm` is retired and must be absent —\n--!         a stale `hm`-bearing payload fails loudly rather than degrading to\n--!         a value-less entry. The optional document metadata `i`, `v`, and\n--!         `h` is accepted because selector lookup grafts it onto the entry\n--!         before casting to `public.eql_v3_json_entry`.\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 NOT (val ? 'hm')\n     AND (NOT (val ? 'a') OR jsonb_typeof(val -> 'a') = 'boolean')\n     AND (NOT (val ? 'op') OR jsonb_typeof(val -> 'op') = 'string')\n     AND val - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\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--!         a string `s`, no ciphertext, an optional string `op` (present only\n--!         on ordered path entries), and no `hm`. A containment needle is a\n--!         set of selectors — a value-selector's presence in the stored\n--!         document IS the exact value match.\n--! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the\n--!   eql_v3.query_json 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 val - 'sv' = '{}'::jsonb\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 NOT (elem ? 'hm')\n         AND (NOT (elem ? 'op') OR jsonb_typeof(elem -> 'op') = 'string')\n         AND elem - ARRAY['s', 'op']::text[] = '{}'::jsonb\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`, a string key header `h`, an `sv` array, and valid\n--!         sv entry elements. `h` carries the document's key-retrieval\n--!         material once (every entry encrypts under the document's single\n--!         data key; entry `c` values are raw AEAD output whose nonces are\n--!         derived from the entries' selectors) — it is opaque to SQL and\n--!         only ever carried/grafted, never parsed. Unknown envelope keys are\n--!         rejected; `k` and `a` remain optional compatibility fields.\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 -> 'h') = 'string'\n     AND jsonb_typeof(val -> 'sv') = 'array'\n     AND val - ARRAY['v', 'k', 'i', 'h', 'sv', 'a']::text[] = '{}'::jsonb\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, `i` index\n--! metadata, and the key header `h`). Root `c` is intentionally NOT required —\n--! an sv-array root payload is `{i, v, h, sv}` with no root ciphertext (the\n--! root document ciphertext lives on the root sv entry). The CHECK also\n--! requires an `sv` array, so the domain accepts only SteVec **document**\n--! payloads and rejects encrypted *scalar* payloads (which carry `c`/`hm`/`ob`\n--! but no `sv`) — this is what keeps `public.eql_v3_json_search` a typed\n--! document domain rather than a generic encrypted envelope. The firewall in\n--! blockers.sql attaches to this domain to stop native jsonb operators from\n--! reaching a column value.\n--!\n--! @note Constructing from inline JSON uses the standard DOMAIN cast:\n--!       `'{\"i\":{},\"v\":3,\"h\":\"...\",\"sv\":[...]}'::public.eql_v3_json_search`.\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'eql_v3_json_search' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_search 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_search IS 'EQL encrypted JSONB searchable document (containment)';\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`) and a ciphertext (`c`), plus — for an ordered (number/string) path\n--! entry only — a string `op` (CLLW OPE, for ordered queries). Value entries\n--! (value-inclusive selectors) and non-orderable path entries are term-less\n--! `{s, c}`: exact matching is selector presence, so there is no per-value\n--! equality term (`hm` is retired and rejected). This is the type returned by\n--! `->` and accepted by the per-entry extractors `eql_v3.ope_term` /\n--! `eql_v3.ord_term`. The deprecated `eq_term(json_entry)` name aliases\n--! `ope_term`. The optional array marker `a` and root `i`/`v`/`h`\n--! metadata merged in by `->` are the only additional fields accepted.\n--!\n--! @see src/v3/json/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_json_entry' AND typnamespace = 'public'::regnamespace\n  ) THEN\n    CREATE DOMAIN public.eql_v3_json_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 NOT (VALUE ? 'hm')\n           AND (NOT (VALUE ? 'a') OR jsonb_typeof(VALUE -> 'a') = 'boolean')\n           AND (NOT (VALUE ? 'op') OR jsonb_typeof(VALUE -> 'op') = 'string')\n           AND VALUE - ARRAY['s', 'c', 'a', 'op', 'i', 'v', 'h']::text[] = '{}'::jsonb,\n          false\n        )\n      );\n  END IF;\n\n  COMMENT ON DOMAIN public.eql_v3_json_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 carries `s`, an optional\n--! `op` (ordered path entries only), and no `hm` — a containment needle is a\n--! set of selectors, and a value-selector's presence in the stored document is\n--! the exact value match. Typing the needle this way stops raw jsonb from\n--! casting and matching every row via bare `jsonb @>`.\n--!\n--! @note Construct from inline JSON via the DOMAIN cast:\n--!       `'{\"sv\":[{\"s\":\"<sel>\"}]}'::eql_v3.query_json`.\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_json_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_json`).\n--! @endinternal\nDO $$\nBEGIN\n  IF NOT EXISTS (\n    SELECT 1 FROM pg_type\n    WHERE typname = 'query_json' AND typnamespace = 'eql_v3'::regnamespace\n  ) THEN\n    CREATE DOMAIN eql_v3.query_json 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_json IS 'EQL JSONB query operand (containment)';\nEND\n$$;\n\n--! @brief Convert a public.eql_v3_json_search to a query_json needle.\n--!\n--! Normalises each sv element down to its selector `s`. Exact and structural\n--! containment are both selector-set containment; an `op` carried by a legacy\n--! or document-derived needle is accepted at the boundary for compatibility\n--! but is not part of the containment predicate. Other fields are stripped.\n--! This is the canonical needle shape for `@>` containment and the functional\n--! GIN index expression:\n--!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.\n--!\n--! @param e public.eql_v3_json_search Source encrypted payload\n--! @return eql_v3.query_json Query-shaped needle, sv elements normalised.\n--! @see eql_v3.query_json\nCREATE FUNCTION eql_v3.to_ste_vec_query(e public.eql_v3_json_search)\n  RETURNS eql_v3.query_json\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                  )\n                )\n              )\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\n--! @brief Normalise an already query-shaped needle to selector-only form.\n--!\n--! Some producers derive a query from a complete encrypted document and may\n--! therefore carry the path entry's `op`. Containment is selector-set\n--! containment, so this overload strips `op` before comparison and keeps every\n--! public containment entry point semantically identical.\nCREATE FUNCTION eql_v3.to_ste_vec_query(e eql_v3.query_json)\n  RETURNS eql_v3.query_json\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT jsonb_build_object(\n    'sv',\n    coalesce(\n      (SELECT jsonb_agg(jsonb_build_object('s', elem -> 's'))\n       FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),\n      '[]'::jsonb\n    )\n  )::eql_v3.query_json\n$$;\n\nCREATE CAST (public.eql_v3_json_search AS eql_v3.query_json)\n  WITH FUNCTION eql_v3.to_ste_vec_query(public.eql_v3_json_search)\n  AS ASSIGNMENT;\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--! @code{.sql}\n--! SELECT severity, category, object_name, message\n--!   FROM eql_v3.lints()\n--!  WHERE severity = 'error'\n--!  ORDER BY category, object_name;\n--! @endcode\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-- 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 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 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/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/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 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/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\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/json/blockers.sql\n--! @brief Native-jsonb firewall for public.eql_v3_json_search.\n--!\n--! public.eql_v3_json_search SUPPORTS @> <@ -> ->> (see operators.sql). Comparisons\n--! Ordered comparisons < <= > >= are supported on public.eql_v3_json_entry;\n--! entry equality = <> is blocked because path entries carry no exact value\n--! selector. Root-document comparisons are also blocked.\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_search 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_search, 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_search', '?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: ?| (any key exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?|');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_any,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: ?& (all keys exist).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '?&');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.jsonb_blocked_exists_all,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: @? (jsonpath exists).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@?');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_exists,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: @@ (jsonpath predicate).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '@@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_jsonpath_match,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = jsonpath\n);\n\n--! @brief Blocker: #> (path extract, native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #>> (path extract as text).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#>>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_path_extract_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: - (delete key, text RHS; native returns jsonb).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_text,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text\n);\n\n--! @brief Blocker: - (delete index, integer RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_int,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = integer\n);\n\n--! @brief Blocker: - (delete keys, text[] RHS).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_array,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: #- (delete at path).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '#-');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.jsonb_blocked_delete_path,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = text[]\n);\n\n--! @brief Blocker: || (concatenate, encrypted on the left).\n--! @param a public.eql_v3_json_search 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_search, 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_search', '||');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.jsonb_blocked_concat,\n  LEFTARG = public.eql_v3_json_search,\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_search 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_search)\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_search', '||');\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_search\n);\n\n------------------------------------------------------------------------------\n-- Root-document comparison blockers.\n------------------------------------------------------------------------------\n\n--! @brief Blocker: root public.eql_v3_json_search document comparisons.\n--! @param a public.eql_v3_json_search Left operand (encrypted payload).\n--! @param b public.eql_v3_json_search 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_search, b public.eql_v3_json_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root public.eql_v3_json_search-to-jsonb comparisons.\n--! @param a public.eql_v3_json_search 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_search, 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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: root jsonb-to-public.eql_v3_json_search comparisons.\n--! @param a jsonb Native LHS operand.\n--! @param b public.eql_v3_json_search 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_search)\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_search', 'comparison');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_json,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.jsonb_blocked_compare_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\n------------------------------------------------------------------------------\n-- Dropped single-entry containment blockers.\n------------------------------------------------------------------------------\n\n--! @brief Block document containment against an extracted path entry.\n--! @param a public.eql_v3_json_search Encrypted document.\n--! @param b public.eql_v3_json_entry Extracted path entry.\n--! @return boolean Never returns; always raises 'operator not supported'.\n--! @note An extracted path entry carries no value selector, so this signature\n--!       cannot express exact equality. It is explicitly claimed to prevent\n--!       PostgreSQL flattening both domains to native jsonb containment.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_contains_entry(a public.eql_v3_json_search, b public.eql_v3_json_entry)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_entry,\n  LEFTARG = public.eql_v3_json_search,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block reverse containment from an extracted path entry.\n--! @param a public.eql_v3_json_entry Extracted path entry.\n--! @param b public.eql_v3_json_search Encrypted document.\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3_internal.jsonb_blocked_entry_contained(a public.eql_v3_json_entry, b public.eql_v3_json_search)\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_entry', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_entry_contained,\n  LEFTARG = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_search\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_search 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_search, 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_search', '@>');\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_search 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_search)\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_search', '@>');\nEND;\n$$ LANGUAGE plpgsql;\n\n--! @brief Blocker: <@ with encrypted root document and native jsonb.\n--! @param a public.eql_v3_json_search 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_search, 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_search', '<@');\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_search 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_search)\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_search', '<@');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contains_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.jsonb_blocked_contained_json_jsonb,\n  LEFTARG = public.eql_v3_json_search,\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_search\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return public.eql_v3_bigint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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/boolean/boolean_functions.sql\n--! @brief Functions for public.eql_v3_boolean.\n\n--! @brief Unsupported operator blocker for public.eql_v3_boolean.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return public.eql_v3_boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_boolean right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_boolean left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_boolean and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_boolean right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/date/date_functions.sql\n--! @brief Functions for public.eql_v3_date.\n\n--! @brief Unsupported operator blocker for public.eql_v3_date.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return public.eql_v3_date never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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/double/double_functions.sql\n--! @brief Functions for public.eql_v3_double.\n\n--! @brief Unsupported operator blocker for public.eql_v3_double.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return public.eql_v3_double never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return public.eql_v3_integer never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 v3/scalars/json/json_types.sql\n--! @brief Encrypted-domain types for json.\n\nDO $$\nBEGIN\n  --! @brief Encrypted domain public.eql_v3_json.\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        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_json IS 'EQL encrypted json (storage only)';\nEND\n$$;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_functions.sql\n--! @brief Functions for public.eql_v3_json.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector text)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a public.eql_v3_json, selector integer)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return public.eql_v3_json never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->\"(a jsonb, selector public.eql_v3_json)\nRETURNS public.eql_v3_json IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector text)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a public.eql_v3_json, selector integer)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_json right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"->>\"(a jsonb, selector public.eql_v3_json)\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '->>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?\"(a public.eql_v3_json, b text)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?|\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?|', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"?&\"(a public.eql_v3_json, b text[])\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '?&', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@?\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@?', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonb)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a jsonb, b public.eql_v3_json)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(a public.eql_v3_json, b jsonpath)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '@@', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#>>\"(a public.eql_v3_json, b text[])\nRETURNS text IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#>>', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b integer)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"#-\"(a public.eql_v3_json, b text[])\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '#-', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a public.eql_v3_json, b jsonb)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_json right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"||\"(a jsonb, b public.eql_v3_json)\nRETURNS jsonb IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '||', 'public.eql_v3_json'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/json/json_operators.sql\n--! @brief Operators for public.eql_v3_json.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR -> (\n  FUNCTION = eql_v3_internal.\"->\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR ->> (\n  FUNCTION = eql_v3_internal.\"->>\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR ? (\n  FUNCTION = eql_v3_internal.\"?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR ?| (\n  FUNCTION = eql_v3_internal.\"?|\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR ?& (\n  FUNCTION = eql_v3_internal.\"?&\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR @? (\n  FUNCTION = eql_v3_internal.\"@?\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3_internal.\"@@\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonpath\n);\n\nCREATE OPERATOR #> (\n  FUNCTION = eql_v3_internal.\"#>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #>> (\n  FUNCTION = eql_v3_internal.\"#>>\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = integer\n);\n\nCREATE OPERATOR - (\n  FUNCTION = eql_v3_internal.\"-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR #- (\n  FUNCTION = eql_v3_internal.\"#-\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = text[]\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = public.eql_v3_json\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = public.eql_v3_json, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR || (\n  FUNCTION = eql_v3_internal.\"||\",\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_json\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return public.eql_v3_numeric never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return public.eql_v3_real never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return public.eql_v3_smallint never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 (matching)';\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, matching)';\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, matching)';\nEND\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 (matching)';\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, matching)';\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, matching)';\nEND\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return public.eql_v3_text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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 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 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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return public.eql_v3_timestamp never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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 = 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\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\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 `matches` fuzzy-match capability (the public `@@` operator /\n--! `eql_v3.matches`) on the text match/search domains. The filter is read from\n--! the `bf` field of an encrypted jsonb payload. The match wrapper body reduces\n--! to native `smallint[]` array-containment (`@>`) on this domain — inherited\n--! through the base type — so a functional GIN index on `eql_v3.match_term(col)`\n--! engages; this type itself needs no custom operators.\n--!\n--! @note The public operator is `@@` (fuzzy bloom-token matching), NOT the\n--!   containment operators `@>`/`<@`: the match is a probabilistic, one-sided\n--!   n-gram token match, not containment. `@>`/`<@` on the text match\n--!   domains now raise. Internally the `@@` wrapper still reduces to the base\n--!   type's `@>` for GIN indexability.\n--! @note Self-contained: references no eql_v2 symbol.\nCREATE DOMAIN eql_v3_internal.bloom_filter AS smallint[];\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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return public.eql_v3_text_match never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_match right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_match, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_match) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_match)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_match) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_match)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_match.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_match left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_match and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_match right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_match, b eql_v3.query_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_match, b public.eql_v3_text_match)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = eql_v3.query_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_match, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_match,\n  RESTRICT = contsel, JOIN = contjoinsel\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\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/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 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return public.eql_v3_bigint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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-- 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 = 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\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-- 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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return public.eql_v3_date_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return public.eql_v3_double_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return public.eql_v3_integer_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return public.eql_v3_numeric_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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 = 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\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/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/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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return public.eql_v3_real_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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-- 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 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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return public.eql_v3_smallint_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return public.eql_v3_text_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return public.eql_v3_timestamp_eq never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_eq left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_eq and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_eq right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/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/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 = 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\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\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` / `_ord_ope`\n--! domains); the 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_block_256 (`ob`),\n--! the block-ORE term behind the `_ord_ore` escape hatch, compared by a custom\n--! N-block protocol.\n--!\n--! @note Transient type used only during query execution.\n--! @see eql_v3_internal.ore_block_256\nCREATE DOMAIN eql_v3_internal.ope_cllw AS bytea;\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/json/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 envelope metadata (i, v, h) from a raw jsonb encrypted value.\n--!\n--! `h` is the document's key header — hoisted once to the envelope because\n--! every sv entry encrypts under the document's single data key. Grafting it\n--! here (the same `meta_data(val) || entry` concat that already grafts `i`/`v`)\n--! is what keeps an extracted `public.eql_v3_json_entry` self-contained\n--! decryptable: decryption needs the header plus the entry's own `s` (the\n--! nonce source) and `c` (the raw AEAD output). `jsonb_strip_nulls` drops the\n--! keys entirely on payloads that lack them (e.g. a raw scalar envelope has\n--! no `h`), rather than grafting JSON nulls.\n--!\n--! @param val jsonb encrypted EQL payload\n--! @return jsonb Metadata object with `i`, `v`, and (for documents) `h`.\nCREATE FUNCTION eql_v3.meta_data(val jsonb)\n  RETURNS jsonb\n  IMMUTABLE STRICT PARALLEL SAFE\n  LANGUAGE SQL\nAS $$\n  SELECT jsonb_strip_nulls(\n    jsonb_build_object('i', val->'i', 'v', val->'v', 'h', val->'h')\n  );\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 The `c` field verbatim (base85 text).\n--! @throws Exception if `c` is absent.\n--! @note On the SteVec surface an entry's `c` is raw AEAD output and is NOT\n--!       decryptable on its own: the decryption unit is the entry — its `s`\n--!       (nonce source), `c`, and the document key header `h` (grafted onto\n--!       extracted entries by `->`; see eql_v3.meta_data). Scalar payloads'\n--!       `c` remains a self-describing encrypted record.\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_json_entry\n--! @return text The selector value.\nCREATE FUNCTION eql_v3.selector(entry public.eql_v3_json_entry)\n  RETURNS text\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT entry ->> 's'\n$$;\n\n------------------------------------------------------------------------------\n-- Raw OPE-term extractor\n------------------------------------------------------------------------------\n\n--! @brief Low-level deterministic OPE byte extractor for a json entry.\n--!\n--! Returns the bytea of the entry's deterministic `op` (CLLW OPE) term, or NULL\n--! for a term-less entry (a value entry, or a bool/null/structural path entry —\n--! which carry no term because exact matching there is selector presence, not a\n--! per-entry term). Entry-to-entry `=` / `<>` are blocked: these bytes are an\n--! ordering encoding, not an exact equality representation.\n--!\n--! `op` is deterministic (equal plaintext at a fixed selector ⇒ equal bytes),\n--! so byte equality on it is a sound equality for number/string leaves — with\n--! the same encoding caveat as the scalar `_ord` surface (f64 rounding, string\n--! collation make it lossy for `bigint`/`numeric`/`text`). Exact, loss-free\n--! equality on a JSON field is selector presence (containment / the value\n--! selector), not this term. This extractor remains available only for callers\n--! that deliberately need encoded OPE-equivalence buckets. `hm` is retired —\n--! entries no longer carry it.\n--!\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL if the entry has no `op`, or is NULL).\nCREATE FUNCTION eql_v3.ope_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT decode(entry ->> 'op', 'hex')\n$$;\n\n--! @brief Deprecated compatibility alias for eql_v3.ope_term(json_entry).\n--! @deprecated Use eql_v3.ope_term for raw OPE-equivalence inspection, or\n--!             eql_v3.ord_term for ordered comparisons. This term is not an\n--!             exact equality representation.\n--! @param entry public.eql_v3_json_entry\n--! @return bytea Decoded `op` bytes (NULL when the entry has no `op`).\nCREATE FUNCTION eql_v3.eq_term(entry public.eql_v3_json_entry)\n  RETURNS bytea\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.ope_term(entry)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.eq_term(public.eql_v3_json_entry) IS\n  'DEPRECATED: use eql_v3.ope_term(json_entry); OPE bytes are not exact equality terms';\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_json_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_json_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_json_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 containment fields (s) 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--! Exact and structural containment are selector-set containment, so ordering\n--! terms are deliberately excluded.\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 = 's'\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_search` `@>` operator does NOT call this function — it binds to\n--!       `eql_v3.jsonb_document_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_search` `<@` operator binds to `eql_v3.jsonb_document_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**. Containment reduces to selector-set subset\n--! testing: a leaf's value is tokenized into its **value selector**\n--! (`SEL(tag ‖ path ‖ value)`), so the presence of a needle's value selector\n--! in the stored `sv` IS the exact value match — a keyed-MAC comparison,\n--! injective per (path, value), immune to the ordering encoding's losses\n--! (f64 rounding, string collation). Structural containment rides the same\n--! test: a needle's path selector (`SEL(path)`, value-independent) matches any\n--! stored node at that path, and the needle's value selectors constrain the\n--! values. No per-entry term comparison is involved — the value is in the\n--! selector, not in a term.\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's selector is present in any element of a.\nCREATE FUNCTION eql_v3.jsonb_document_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 (eql_v3.selector(_a) = eql_v3.selector(b));\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 have its selector\n--! present in some element of a (selector-subset containment).\n--!\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\n--! @see eql_v3.jsonb_document_contains(jsonb[], jsonb)\nCREATE FUNCTION eql_v3.jsonb_document_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\n--! @cond deprecated_compatibility\n--! @brief Deprecated compatibility alias for jsonb_document_contains(jsonb[], jsonb).\n--! @deprecated Use eql_v3.jsonb_document_contains(jsonb[], jsonb).\n--! @param a jsonb[] sv array to search within.\n--! @param b jsonb sv element to search for.\n--! @return boolean True if b's selector is present in any element of a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a jsonb[], b jsonb)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(jsonb[], jsonb) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(jsonb[], jsonb)';\n\n--! @brief Deprecated compatibility alias for jsonb_document_contains(json_search, json_search).\n--! @deprecated Use eql_v3.jsonb_document_contains(public.eql_v3_json_search, public.eql_v3_json_search).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Elements to find.\n--! @return boolean True if all elements of b are contained in a.\nCREATE FUNCTION eql_v3.ste_vec_contains(a public.eql_v3_json_search, b public.eql_v3_json_search)\n  RETURNS boolean\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCOMMENT ON FUNCTION eql_v3.ste_vec_contains(public.eql_v3_json_search, public.eql_v3_json_search) IS\n  'DEPRECATED: use eql_v3.jsonb_document_contains(json_search, json_search)';\n--! @endcond\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_search document, because the root document domain requires an `sv`\n--! array and single leaves belong to public.eql_v3_json_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_json_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_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_entry First matching element or NULL.\nCREATE FUNCTION eql_v3.jsonb_path_query_first(val jsonb, selector text)\n  RETURNS public.eql_v3_json_entry\n  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT (eql_v3.meta_data(val) || elem)::public.eql_v3_json_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_json_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_json_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_json_entry;\n    END LOOP;\n\n    RETURN;\n  END;\n$$ LANGUAGE plpgsql;\n\n-- NOTE: `eql_v3.jsonb_array_elements_text` (SETOF bare per-element ciphertext\n-- text) was removed with the envelope wire format: an sv entry's `c` is raw\n-- AEAD output whose nonce derives from the entry's `s`, so a bare ciphertext\n-- stream is not decryptable and the function had no remaining correct use.\n-- Use `eql_v3.jsonb_array_elements` — its entry rows carry `s`, `c`, and the\n-- grafted document key header `h`, the complete decryption unit.\n\n--! @file v3/json/aggregates.sql\n--! @brief min / max aggregates over public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The lesser orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_min_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the smallest CLLW OPE term.\nCREATE AGGREGATE eql_v3.min(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_min_sfunc,\n  stype = public.eql_v3_json_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_json_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_json_entry Running extremum.\n--! @param value public.eql_v3_json_entry Candidate entry.\n--! @return public.eql_v3_json_entry The greater orderable entry by `ord_term`.\nCREATE FUNCTION eql_v3_internal.jsonb_entry_max_sfunc(\n  state public.eql_v3_json_entry,\n  value public.eql_v3_json_entry\n)\nRETURNS public.eql_v3_json_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_json_entry.\n--! @param input public.eql_v3_json_entry\n--! @return public.eql_v3_json_entry The entry with the largest CLLW OPE term.\nCREATE AGGREGATE eql_v3.max(public.eql_v3_json_entry) (\n  sfunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  stype = public.eql_v3_json_entry,\n  combinefunc = eql_v3_internal.jsonb_entry_max_sfunc,\n  parallel = safe\n);\n\n--! @file v3/json/operators.sql\n--! @brief Operators on public.eql_v3_json_search and public.eql_v3_json_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: range predicates reduce structurally through\n--! `eql_v3.ord_term(col -> 'sel')` and match a functional btree index on that\n--! expression. Exact equality is document containment on a value selector.\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_search`\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_search Root encrypted payload.\n--! @param selector text Selector hash.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector text)\n  RETURNS public.eql_v3_json_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_json_entry\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=text\n);\n\n--! @brief -> operator with integer array index (0-based, JSONB convention).\n--! @param e public.eql_v3_json_search Encrypted sv-array payload.\n--! @param selector integer Array index.\n--! @return public.eql_v3_json_entry Matching entry merged with root meta, or NULL.\nCREATE FUNCTION eql_v3.\"->\"(e public.eql_v3_json_search, selector integer)\n  RETURNS public.eql_v3_json_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_search` to\n      -- its base type and binds native `jsonb -> text` (see the @warning above) —\n      -- the custom `->(public.eql_v3_json_search, 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_search, integer)`\n      -- operator instead of native array access.\n      (eql_v3.meta_data(e) || (e::jsonb -> 'sv' -> selector))::public.eql_v3_json_entry\n    ELSE NULL\n  END\n$$;\n\nCREATE OPERATOR ->(\n  FUNCTION=eql_v3.\"->\",\n  LEFTARG=public.eql_v3_json_search,\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_search 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_search, 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_search,\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_search 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_search, 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_search,\n  RIGHTARG=integer\n);\n\n------------------------------------------------------------------------------\n-- @> containment\n------------------------------------------------------------------------------\n\n--! @brief @> contains operator (document, document).\n--! @param a public.eql_v3_json_search Container.\n--! @param b public.eql_v3_json_search Contained value.\n--! @return boolean True if a contains b.\n--! @see eql_v3.jsonb_document_contains\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.jsonb_document_contains(a, b)\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief @> contains operator with an query_json 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_search Container.\n--! @param b eql_v3.query_json Query payload.\n--! @return boolean True if a contains b.\nCREATE FUNCTION eql_v3.\"@>\"(a public.eql_v3_json_search, b eql_v3.query_json)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(a)::jsonb\n       @> eql_v3.to_ste_vec_query(b)::jsonb\n$$;\n\nCREATE OPERATOR @>(\n  FUNCTION=eql_v3.\"@>\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=eql_v3.query_json\n);\n\n-- NOTE: there is deliberately NO computable `@>`(json_search, json_entry)\n-- single-entry containment operator. `blockers.sql` claims the signature and\n-- raises rather than allowing native-jsonb fallback. An extracted `json_entry` is a PATH entry\n-- ({s,c,op?}) and carries no value selector, so it can only ever match\n-- structurally (\"the document has a node at this path\") — value-blind for\n-- bool/null/object/array and op-lossy for number/string. Exact field equality is\n-- document containment on the value selector: `col @> $1::eql_v3.query_json`,\n-- where a value-selector's presence in the stored document IS the exact match.\n-- Routing all value equality through that one exact mechanism is why the\n-- structural single-entry behavior (and its `<@` reverse) was blocked.\n\n------------------------------------------------------------------------------\n-- <@ contained-by (reverse of @>)\n------------------------------------------------------------------------------\n\n--! @brief <@ contained-by operator (document, document).\n--! @param a public.eql_v3_json_search Contained value.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if a is contained by b.\nCREATE FUNCTION eql_v3.\"<@\"(a public.eql_v3_json_search, b public.eql_v3_json_search)\nRETURNS boolean\nLANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE\nAS $$\n  SELECT eql_v3.to_ste_vec_query(b)::jsonb\n       @> eql_v3.to_ste_vec_query(a)::jsonb\n$$;\n\nCREATE OPERATOR <@(\n  FUNCTION=eql_v3.\"<@\",\n  LEFTARG=public.eql_v3_json_search,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n--! @brief <@ contained-by operator with an query_json LHS.\n--! @param a eql_v3.query_json Query payload.\n--! @param b public.eql_v3_json_search Container.\n--! @return boolean True if b contains a.\nCREATE FUNCTION eql_v3.\"<@\"(a eql_v3.query_json, b public.eql_v3_json_search)\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_json,\n  RIGHTARG=public.eql_v3_json_search\n);\n\n-- NOTE: `<@`(json_entry, json_search) is likewise a fail-loud blocker — it is\n-- the reverse of the blocked single-entry `@>` behavior. See the note above.\n\n------------------------------------------------------------------------------\n-- jsonb_entry comparisons\n------------------------------------------------------------------------------\n\n--! @brief Block equality between two extracted jsonb entries.\n--! @note An extracted entry is a path entry and carries no value selector.\n--!       Comparing its deterministic `op` bytes would be lossy for\n--!       `bigint`/`numeric`/`text`; exact equality is document containment on a\n--!       value-selector needle. This blocker is deliberately non-STRICT so a\n--!       NULL operand cannot bypass the error.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.eq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '=');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3.eq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Block inequality between two extracted jsonb entries.\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean Never returns; always raises 'operator not supported'.\nCREATE FUNCTION eql_v3.neq(a public.eql_v3_json_entry, b public.eql_v3_json_entry)\n  RETURNS boolean\n  IMMUTABLE PARALLEL SAFE\n  SET search_path = pg_catalog, extensions, public\nAS $$\nBEGIN\n  RETURN eql_v3_internal.encrypted_domain_unsupported_bool('public.eql_v3_json_entry', '<>');\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3.neq,\n  LEFTARG  = public.eql_v3_json_entry,\n  RIGHTARG = public.eql_v3_json_entry\n);\n\n--! @brief Less-than on jsonb_entry via the CLLW OPE term (native bytea order).\n--! @param a public.eql_v3_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is less than b\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_entry Right operand\n--! @return boolean True if a is greater than b\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_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_json_entry Left operand\n--! @param b public.eql_v3_json_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_json_entry, b public.eql_v3_json_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_json_entry,\n  RIGHTARG = public.eql_v3_json_entry,\n  COMMUTATOR = <=,\n  NEGATOR  = <,\n  RESTRICT = scalargesel,\n  JOIN     = scalargejoinsel\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_bigint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_bigint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_bigint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_bigint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_bigint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_bigint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_bigint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_bigint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return public.eql_v3_date_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/json_entry_date_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_date_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_date_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_date_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_date_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/date/json_entry_date_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_date_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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_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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return public.eql_v3_double_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_double_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_double_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_double_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_double_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_double_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_double_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.eql_v3_json_entry)\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/json_entry_double_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_double_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return public.eql_v3_integer_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_integer_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_integer_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_integer_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_integer_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_integer_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_integer_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.eql_v3_json_entry)\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/json_entry_integer_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_integer_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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_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 = 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\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_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/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/json_entry_numeric_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_numeric_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_numeric_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_numeric_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_numeric_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_numeric_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.eql_v3_json_entry)\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/json_entry_numeric_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_numeric_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return public.eql_v3_real_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_real_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_real_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_real_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_real_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_real_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_real_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.eql_v3_json_entry)\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/json_entry_real_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_real_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_smallint_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_smallint_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_smallint_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_smallint_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_smallint_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_smallint_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.eql_v3_json_entry)\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/json_entry_smallint_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_smallint_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\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/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 = 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\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_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_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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return public.eql_v3_text_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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/json_entry_text_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Operator wrapper for public.eql_v3_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean 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_json_entry.\n--! @param a public.eql_v3_json_entry\n--! @param b eql_v3.query_text_ord_ope\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a public.eql_v3_json_entry, 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 public.eql_v3_json_entry.\n--! @param a eql_v3.query_text_ord_ope\n--! @param b public.eql_v3_json_entry\n--! @return boolean\nCREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE\nAS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_text_search)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_text_search left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_text_search, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/text/json_entry_text_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3.lt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3.lte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3.gt,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3.gte,\n  LEFTARG = public.eql_v3_json_entry, 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_json_entry,\n  COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_text_search\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_json_entry\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/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 = 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\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_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_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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return public.eql_v3_text_search never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search, b eql_v3.query_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search, b public.eql_v3_text_search)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = eql_v3.query_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/timestamp/json_entry_timestamp_functions.sql\n--! @brief Functions for public.eql_v3_json_entry.\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.eq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.neq(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.lte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '<=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gt(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_json_entry left operand of the blocked operator\n--! @param b eql_v3.query_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a public.eql_v3_json_entry, b eql_v3.query_timestamp_ord_ope)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n\n--! @brief Unsupported operator blocker for public.eql_v3_json_entry.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_json_entry and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a eql_v3.query_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_json_entry right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.gte(a eql_v3.query_timestamp_ord_ope, b public.eql_v3_json_entry)\nRETURNS boolean IMMUTABLE PARALLEL SAFE\nAS $$ BEGIN RAISE EXCEPTION 'operator % is not supported for %', '>=', 'public.eql_v3_json_entry'; END; $$\nLANGUAGE plpgsql;\n-- AUTOMATICALLY GENERATED FILE.\n\n--! @file encrypted_domain/timestamp/json_entry_timestamp_operators.sql\n--! @brief Operators for public.eql_v3_json_entry.\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR = (\n  FUNCTION = eql_v3_internal.eq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <> (\n  FUNCTION = eql_v3_internal.neq,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR < (\n  FUNCTION = eql_v3_internal.lt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR <= (\n  FUNCTION = eql_v3_internal.lte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR > (\n  FUNCTION = eql_v3_internal.gt,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = public.eql_v3_json_entry, RIGHTARG = eql_v3.query_timestamp_ord_ope\n);\n\nCREATE OPERATOR >= (\n  FUNCTION = eql_v3_internal.gte,\n  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.eql_v3_json_entry\n);\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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 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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ope never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ope left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ope and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ope right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 = 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\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_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\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/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-- 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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_bigint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_bigint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_bigint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_bigint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_date_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_date_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_date_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_date_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_double_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_double_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_double_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_double_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_integer_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_integer_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_integer_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_integer_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_numeric_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_numeric_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_numeric_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_numeric_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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_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 = 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\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_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/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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_real_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_real_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_real_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_real_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_smallint_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_smallint_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_smallint_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_smallint_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_text_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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_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 Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contains(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a public.eql_v3_text_search_ore, b jsonb)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.contained_by(a jsonb, b public.eql_v3_text_search_ore)\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return public.eql_v3_text_search_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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 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.matches(a public.eql_v3_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a public.eql_v3_text_search_ore, b jsonb)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b::public.eql_v3_text_search_ore) AND (cardinality(eql_v3.match_term(b::public.eql_v3_text_search_ore)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a jsonb, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a::public.eql_v3_text_search_ore) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a::public.eql_v3_text_search_ore)) = 0) $$;\n\n--! @brief Unsupported operator blocker for public.eql_v3_text_search_ore.\n--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_text_search_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_text_search_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_text_search_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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.matches(a public.eql_v3_text_search_ore, b eql_v3.query_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches(a eql_v3.query_text_search_ore, b public.eql_v3_text_search_ore)\nRETURNS boolean LANGUAGE sql IMMUTABLE PARALLEL SAFE\nAS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) AND (cardinality(eql_v3.match_term(b)) > 0 OR cardinality(eql_v3.match_term(a)) = 0) $$;\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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = eql_v3.query_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = eql_v3.query_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\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_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR @> (\n  FUNCTION = eql_v3_internal.contains,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb\n);\n\nCREATE OPERATOR <@ (\n  FUNCTION = eql_v3_internal.contained_by,\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 = 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.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = public.eql_v3_text_search_ore, RIGHTARG = jsonb,\n  RESTRICT = contsel, JOIN = contjoinsel\n);\n\nCREATE OPERATOR @@ (\n  FUNCTION = eql_v3.matches,\n  LEFTARG = jsonb, RIGHTARG = public.eql_v3_text_search_ore,\n  RESTRICT = contsel, JOIN = contjoinsel\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_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/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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return public.eql_v3_timestamp_ord_ore never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector text right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param selector integer right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param selector public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\nCREATE FUNCTION eql_v3_internal.\"@@\"(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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonpath right operand of the blocked operator\n--! @return boolean never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return text never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b integer right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b text[] right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a public.eql_v3_timestamp_ord_ore left operand of the blocked operator\n--! @param b jsonb right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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--!\n--! Intercepts an operator that is not supported on public.eql_v3_timestamp_ord_ore and always raises;\n--! it never returns a value. The declared signature exists only so the operator\n--! resolves to this blocker instead of a base-type fallback.\n--!\n--! @param a jsonb left operand of the blocked operator\n--! @param b public.eql_v3_timestamp_ord_ore right operand of the blocked operator\n--! @return jsonb never returned — the function always raises \"operator not supported\"\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/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_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/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 = 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\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_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\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 v3/scalars/ore_fallback.sql\n--! @brief Disable the ORE-backed encrypted domains when the ORE operator class is absent.\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-- 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.5 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.5';\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.5';\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": [
diff --git a/packages/stack-prisma/test/v3/migration-v3.test.ts b/packages/stack-prisma/test/v3/migration-v3.test.ts
index cd8b63d43..e495201f0 100644
--- a/packages/stack-prisma/test/v3/migration-v3.test.ts
+++ b/packages/stack-prisma/test/v3/migration-v3.test.ts
@@ -117,18 +117,18 @@ const PUBLISHED_MIGRATIONS = [
     // pinned release rather than a historical one, which is why the
     // lockstep test below has something to match.
     migrationHash:
-      'sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05',
+      'sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313',
     installSqlSha256:
-      '7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad',
+      'accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048',
   },
   {
     dirName: CIPHERSTASH_V3_305_UPGRADE_MIGRATION_NAME,
     metadata: v3Upgrade305Metadata,
     ops: v3Upgrade305Ops,
     migrationHash:
-      'sha256:7bafd9d6c5d244332ff0b0943604dbd026c8369e24d2f335b1365c5f78e49d38',
+      'sha256:3b2b838bee634f2de4a5e88f1625a45d47c327e3021b0e2ccba36c09a9666178',
     installSqlSha256:
-      '7ad9c9f884083979c1cf483ff4f68d2569257d6c6fab15d9e4586f4c93703cad',
+      'accde0030b8f356af616175640635f67661d51aa900624b7fb0fb059e8115048',
   },
   {
     dirName: CIPHERSTASH_V3_304_UPGRADE_MIGRATION_NAME,
@@ -418,14 +418,42 @@ describe('v3 baseline migration (20260601T0100_install_eql_v3_bundle)', () => {
     expect(runtimeUpgrade.ops).toEqual(v3Upgrade305Ops)
   })
 
-  it('the 3.0.5 upgrade edge carries the renamed jsonb_document_contains', () => {
+  it('the 3.0.5 upgrade edge carries the rename AND the deprecated aliases', () => {
     // The behavioural content of this release: `eql_v3.ste_vec_contains`
-    // became `eql_v3.jsonb_document_contains`. Assert against the baked
-    // bytes, so an upgrade edge that ships a bundle without the rename
-    // (the skew this whole lockstep scheme exists to catch) fails here.
+    // became `eql_v3.jsonb_document_contains`, and the old name was KEPT as
+    // a deprecated delegating alias. Assert against the baked bytes, so an
+    // upgrade edge shipping a bundle without the rename — the skew this
+    // whole lockstep scheme exists to catch — fails here.
+    //
+    // This asserted `not.toContain('ste_vec_contains')` until upstream
+    // 142f41d8 restored both overloads as aliases, which is what makes 3.0.5
+    // a genuinely non-breaking patch: the operators never moved, the
+    // PostgREST-facing `jsonb_contains`/`jsonb_contained_by` never moved, and
+    // now direct callers of the old name keep working too. Asserting absence
+    // would now fail against the published bundle — so assert the SHAPE
+    // instead: exactly two alias definitions, both delegating to the new
+    // name, and no remaining call site that still routes through the old one.
     const sql = firstExecuteSql(v3Upgrade305Ops)
     expect(sql).toContain('eql_v3.jsonb_document_contains')
-    expect(sql).not.toContain('ste_vec_contains')
+
+    const aliasDefs = sql.match(/CREATE FUNCTION eql_v3\.ste_vec_contains\(/g)
+    expect(aliasDefs).toHaveLength(2)
+
+    // Delegation, not a second copy of the implementation: every alias body
+    // is a one-line SELECT through the new name. A duplicated body would
+    // drift from the real implementation with nothing to catch it.
+    for (const body of sql.matchAll(
+      /CREATE FUNCTION eql_v3\.ste_vec_contains\([^)]*\)[\s\S]*?\$\$([\s\S]*?)\$\$/g,
+    )) {
+      expect(body[1]).toContain('eql_v3.jsonb_document_contains')
+    }
+
+    // Both are marked deprecated in the database itself, not only in the
+    // generated docs — `COMMENT ON FUNCTION` is what a DBA inspecting the
+    // schema actually sees.
+    expect(
+      sql.match(/COMMENT ON FUNCTION eql_v3\.ste_vec_contains\(/g),
+    ).toHaveLength(2)
   })
 
   it('pins the head ref at the unchanged hash with all invariants', () => {
diff --git a/packages/stack-prisma/test/v3/stale-vendored-space.test.ts b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
index 75ebc7dc5..00b761546 100644
--- a/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
+++ b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
@@ -6,7 +6,7 @@
  *
  * The 3.0.5 release re-emitted the published baseline
  * (`20260601T0100_install_eql_v3_bundle`): its bytes, and so its
- * `migrationHash`, changed from `sha256:fc495f7f…` to `sha256:1ae73282…`.
+ * `migrationHash`, changed from `sha256:fc495f7f…` to `sha256:23c98b03…`.
  * These artefacts are content-addressed and normally append-only, so a
  * re-emit is the one case the machinery was never designed for. The
  * changeset tells consumers to delete the vendored directory and re-run
@@ -307,9 +307,14 @@ describe('stale vendored migrations/cipherstash/ (generated against 1.0.0)', ()
     // …and it is genuinely NOT what the package ships today.
     expect(v3BaselineMetadata.migrationHash).not.toBe(STALE_1_0_0_BASELINE_HASH)
     expect(v3BaselineMetadata.migrationHash).toBe(
-      'sha256:1ae732828e9a6fb3574ab8dbede16e99bf1173bd4e5cd7a4b522138e71bc5d05',
+      'sha256:23c98b0368d22794507a4ef7b02ed4cb04249f36bfcb0b20488005aa62488313',
     )
-    // The stale bundle is pre-rename; the shipped one is post-rename.
+    // The stale bundle is 3.0.4: the old name only. Asserted on the STALE
+    // side alone, deliberately — the shipped 3.0.5 bundle carries BOTH names
+    // (the new one plus the old restored as a deprecated alias in upstream
+    // 142f41d8), so `not.toContain('ste_vec_contains')` is false there and
+    // would be the wrong shape of check. What distinguishes the two artefacts
+    // is that 3.0.4 has no `jsonb_document_contains` at all.
     const staleSql = stale.ops[0]?.execute[0]?.sql ?? ''
     expect(staleSql).toContain('ste_vec_contains')
     expect(staleSql).not.toContain('jsonb_document_contains')

From e266775be281484a838760ea7de048644ce377cd Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 13:57:15 +1000
Subject: [PATCH 17/20] fix(release): drop --offline, which the release job's
 cold registry cannot serve
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`refreshCargoLock` passed `--offline` on the reasoning that `eql-bindings`
resolves from a path and so needs no registry. The premise is true and the
conclusion does not follow: `cargo update -p X` does not update X in
isolation. It re-resolves the whole graph and rewrites a complete lock, and
offline that means every OTHER package has to be served from the local
registry cache. `packages/protect-ffi` has 167 of them.

The release job has no such cache. `jdx/mise-action` runs there with
`install: true, cache: false` — it installs toolchains and populates nothing
under `~/.cargo/registry` — and `lint-no-workflow-caching.mjs` forbids a
cache restore anywhere an artifact is published. Reproduced against this
tree with an empty CARGO_HOME:

    error: no matching package named `chrono` found
    location searched: crates.io index
    required by package `protect-ffi v0.1.0 (…/crates/protect-ffi)`

exit 101. `execFileSync` throws, `pnpm run version` fails, and there is no
Version Packages PR — AFTER `changeset version` has already rewritten every
manifest and CHANGELOG, in a job holding `contents: write`. That is the same
half-applied release the mise-install step above it exists to prevent, and
the sync runs both workspaces before `release:prepare_bindings_assets`, the
only step that would have warmed anything, so the first call dies.

The measurement that made `--offline` look safe was taken on a developer
machine with a warm `~/.cargo`. Both resolutions were re-checked here from
cold and from warm: byte-identical, including the `windows-sys` edge cargo
repairs along the way. So this changes where the step can run, not what it
produces.

The old test asserted `--offline` was present, which pinned the defect
rather than catching it. It now asserts the flag's ABSENCE, paired with a
test of the CI precondition that absence depends on — no cargo cache, no
warm-up step — so that if someone ever warms the registry deliberately, the
coupling is visible instead of buried in a comment. The remediation advice
in `cargo-lock-freshness.test.mjs` recommended the same broken command and
is corrected with it.
---
 .../__tests__/cargo-lock-freshness.test.mjs   |  5 +-
 .../__tests__/sync-lockstep-versions.test.mjs | 91 +++++++++++++++----
 scripts/sync-lockstep-versions.mjs            | 28 ++++--
 3 files changed, 97 insertions(+), 27 deletions(-)

diff --git a/scripts/__tests__/cargo-lock-freshness.test.mjs b/scripts/__tests__/cargo-lock-freshness.test.mjs
index 9106cf5e0..a417b0d9c 100644
--- a/scripts/__tests__/cargo-lock-freshness.test.mjs
+++ b/scripts/__tests__/cargo-lock-freshness.test.mjs
@@ -185,8 +185,9 @@ describe('Cargo.lock records this tree’s crates at their real versions', () =>
     expect(
       offenders,
       'A committed Cargo.lock disagrees with a crate manifest in this tree. Refresh it with ' +
-        '`cargo update --offline --package <crate>` in the workspace holding the lock — no network ' +
-        'needed, because the crate resolves from a path.',
+        '`cargo update --package <crate>` in the workspace holding the lock. Not `--offline`: ' +
+        '`cargo update -p` re-resolves the WHOLE graph, so every other package has to come from ' +
+        'the local registry cache, and it fails outright on a cold one.',
     ).toEqual([])
   })
 })
diff --git a/scripts/__tests__/sync-lockstep-versions.test.mjs b/scripts/__tests__/sync-lockstep-versions.test.mjs
index edd6fbb4d..d00f57533 100644
--- a/scripts/__tests__/sync-lockstep-versions.test.mjs
+++ b/scripts/__tests__/sync-lockstep-versions.test.mjs
@@ -6,6 +6,7 @@ import {
   refreshCargoLock,
 } from '../sync-lockstep-versions.mjs'
 import { REPO_ROOT } from './lib/repo-root.mjs'
+import { readWorkflow } from './lib/workflows.mjs'
 
 const CARGO = `[package]
 name = "eql-bindings"
@@ -63,6 +64,19 @@ serde_json = "1"
   })
 })
 
+/** One `refreshCargoLock` call, as `[command, args, options]`. */
+function captureRefresh() {
+  const calls = []
+  refreshCargoLock({
+    root: '/repo',
+    eqlRoot: '/repo/packages/eql',
+    workspace: 'packages/protect-ffi',
+    run: (...args) => calls.push(args),
+  })
+  expect(calls).toHaveLength(1)
+  return calls[0]
+}
+
 /**
  * The second thing the lockstep bump has to carry, and the one it did not.
  *
@@ -90,17 +104,8 @@ describe('lockstep Cargo.lock refresh', () => {
     expect(found).toContain('packages/protect-ffi')
   })
 
-  test('refreshes offline, through mise, against the named workspace', () => {
-    const calls = []
-    refreshCargoLock({
-      root: '/repo',
-      eqlRoot: '/repo/packages/eql',
-      workspace: 'packages/protect-ffi',
-      run: (...args) => calls.push(args),
-    })
-
-    expect(calls).toHaveLength(1)
-    const [command, args, options] = calls[0]
+  test('refreshes through mise, against the named workspace', () => {
+    const [command, args, options] = captureRefresh()
 
     // THROUGH MISE, not a bare `cargo`. release.yml installs mise with
     // `add_shims_to_path: false` — deliberately, so mise's own Node cannot
@@ -112,17 +117,71 @@ describe('lockstep Cargo.lock refresh', () => {
     expect(args.slice(0, 3)).toEqual(['exec', '--', 'cargo'])
     expect(options.cwd).toBe('/repo/packages/eql')
 
-    // OFFLINE. This runs inside `changeset version`, between the manifest
-    // rewrite and the commit; a registry fetch there is a network dependency
-    // on the release path buying nothing, because the crate resolves from a
-    // path. Verified byte-identical to the networked resolution.
-    expect(args).toContain('--offline')
     expect(args).toContain('--package')
     expect(args).toContain(LOCKED_CRATE)
     expect(args).toContain('--manifest-path')
     expect(args).toContain('/repo/packages/protect-ffi/Cargo.toml')
   })
 
+  /**
+   * NOT `--offline`, and the reason is a property of the job this runs in.
+   *
+   * `--offline` reads as free here — `eql-bindings` resolves from a path, so
+   * why would refreshing it need a registry? Because `cargo update -p X` does
+   * not update X in isolation: it re-resolves the WHOLE graph and rewrites a
+   * complete lock, and in offline mode every other package has to come from
+   * the local registry cache. `packages/protect-ffi` has 167 of them.
+   *
+   * The release job has no such cache. `jdx/mise-action` runs there with
+   * `install: true, cache: false` — it installs toolchains and populates
+   * nothing under `~/.cargo/registry` — and
+   * `scripts/lint-no-workflow-caching.mjs` forbids any cache restore in a
+   * workflow that publishes. So the first call dies:
+   *
+   *   error: no matching package named `chrono` found
+   *   location searched: crates.io index
+   *
+   * — with `execFileSync` throwing, `pnpm run version` failing, and no Version
+   * Packages PR, AFTER `changeset version` has already rewritten every manifest
+   * and CHANGELOG in a job holding `contents: write`. That is the same
+   * half-applied-release failure the mise-install step above exists to prevent.
+   *
+   * The measurement that made `--offline` look safe was taken on a developer
+   * machine with a warm `~/.cargo`. Both resolutions agree — verified on the
+   * 3.0.4 -> 3.0.5 bump, byte-identical including the `windows-sys` edges cargo
+   * repaired along the way — so dropping the flag changes nothing except
+   * whether the step can run at all where it actually runs.
+   */
+  test('does not pass --offline, which cannot resolve on a cold registry', () => {
+    const [, args] = captureRefresh()
+    expect(args).not.toContain('--offline')
+  })
+
+  test('the release job offers no warm cargo registry to resolve against', () => {
+    // The other half of the pair above, asserted against CI rather than
+    // restated in a comment: if this ever stops being true — someone warms the
+    // registry deliberately — then `--offline` becomes available again, and
+    // the test that forbids it should be revisited rather than worked around.
+    const steps = readWorkflow('.github/workflows/release.yml').jobs.release
+      .steps
+
+    const mise = steps.find((s) =>
+      (s.uses ?? '').startsWith('jdx/mise-action@'),
+    )
+    expect(mise, 'release.yml no longer installs mise').toBeDefined()
+    expect(mise.with.cache).toBe(false)
+
+    expect(
+      steps.filter((s) => /\bactions\/cache\b/.test(s.uses ?? '')),
+      'a cache restore in the publishing workflow',
+    ).toEqual([])
+
+    expect(
+      steps.filter((s) => /cargo\s+(fetch|vendor)/.test(s.run ?? '')),
+      'a step that warms the cargo registry',
+    ).toEqual([])
+  })
+
   test('fails loudly rather than leaving a lock stale', () => {
     // A refresh that cannot run must stop the release. The alternative is the
     // state this whole pair of tests exists to end: a bumped manifest, a lock
diff --git a/scripts/sync-lockstep-versions.mjs b/scripts/sync-lockstep-versions.mjs
index b252580db..58f686126 100644
--- a/scripts/sync-lockstep-versions.mjs
+++ b/scripts/sync-lockstep-versions.mjs
@@ -117,11 +117,22 @@ export function cargoLockWorkspaces(root) {
  * `eql-codegen` for the SQL build a few lines below, so there is one Rust here
  * rather than two.
  *
- * `--offline` because the crate resolves from a path and needs no registry.
- * Confirmed byte-identical to the networked resolution on the 3.0.4 -> 3.0.5
- * bump, including the four unrelated `windows-sys` edges cargo repaired along
- * the way. A release-time step should not acquire a network dependency it has
- * no use for.
+ * NOT `--offline`, however tempting it looks. `eql-bindings` resolves from a
+ * path, so the flag reads as free — but `cargo update -p X` does not update X
+ * in isolation. It re-resolves the whole graph and rewrites a complete lock,
+ * and offline that means every OTHER package has to be served from the local
+ * registry cache; `packages/protect-ffi` has 167 of them. The release job has
+ * no such cache — `jdx/mise-action` runs there with `cache: false`, installing
+ * toolchains and populating nothing under `~/.cargo/registry`, and
+ * `scripts/lint-no-workflow-caching.mjs` forbids a cache restore anywhere an
+ * artifact is published. So `--offline` died on the first call with
+ * `error: no matching package named \`chrono\` found`, taking `pnpm run version`
+ * with it AFTER `changeset version` had rewritten every manifest and CHANGELOG.
+ *
+ * The two resolutions agree where both can run — verified byte-identical on the
+ * 3.0.4 -> 3.0.5 bump, `windows-sys` edges included — so this is a change of
+ * where the step works, not of what it produces. Asserted, with the CI
+ * precondition it depends on, in scripts/__tests__/sync-lockstep-versions.test.mjs.
  *
  * `--manifest-path` rather than a second `cwd`, so every cargo invocation in
  * this script runs from the one directory whose mise config is trusted.
@@ -142,7 +153,6 @@ export function refreshCargoLock({
       '--',
       'cargo',
       'update',
-      '--offline',
       '--package',
       LOCKED_CRATE,
       '--manifest-path',
@@ -173,9 +183,9 @@ function main() {
     bumpCargoPackageVersion(readFileSync(cargoPath, 'utf8'), version),
   )
 
-  // Before the SQL build, not after: this is cheap and offline, so a cargo that
-  // cannot run should stop the release in seconds rather than after a full
-  // eql-codegen compile.
+  // Before the SQL build, not after: this is cheap, so a cargo that cannot run
+  // should stop the release in seconds rather than after a full eql-codegen
+  // compile.
   const workspaces = cargoLockWorkspaces(stackRoot)
   if (workspaces.length === 0) {
     throw new Error(

From 93f971a5b8a11982c1d1347081f7a4bce6be0347 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 13:57:31 +1000
Subject: [PATCH 18/20] fix(eql): the doxygen-leak guard could only ever report
 OK
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`docs_v3_grep.sh`'s new check that deprecated `ste_vec_contains` aliases
never reach Doxygen was written as

    elif tasks/docs/doxygen-filter.sh src/v3/json/functions.sql | grep -q …

under `set -euo pipefail`. On the LEAK path — the one the guard exists for —
`grep -q` matches, exits 0 and closes the pipe; the filter's awk takes
SIGPIPE and exits 141; `pipefail` makes that the pipeline's status, so the
`elif` is false and the FAIL branch never runs. Only the clean path (grep
reads to EOF, exits 1) was reported correctly.

This is not latent. Measured at exit 141 against the real ~16 KB filter
output on macOS, whose pipe buffer starts at 16 KB — grepping for a token
that IS in the output returned "no match". Linux's 64 KB buffer absorbs the
write and hides it, which is the same platform split
`workflow-grep-q-pipelines.test.mjs` already documents for GNU tar vs
bsdtar, and the same fail-OPEN direction it warns about.

Fixed by capturing first. The separate assignment also means `set -e` aborts
if the filter itself crashes, where the old pipeline scored a crashed filter
as a pass. Verified in both directions: with the `@cond` markers stripped so
the aliases genuinely leak, the guard now exits 1; before the fix it printed
OK either way.

The guard against the shape now covers tracked shell scripts, not just
`run:` blocks — the hazard is a property of the shell, not of GitHub
Actions. `echo`/`printf` writers are exempt: the whole write lands in the
pipe buffer before grep can exit, so there is no blocked writer to signal.
That exemption is about SIZE, not about them being builtins (a builtin in a
pipeline still runs in a subshell and still takes SIGPIPE), and it is what
keeps the thirteen bounded upstream call sites out of scope while leaving
the one real offender in it.

Whole-line comments are skipped, because the rule has to survive being
written down: the fix comment on `docs_v3_grep.sh` quotes the very pipeline
it replaced, and without that the guard reported the explanation as the
defect.

The fix is in vendored subtree code, so it needs to go upstream to
cipherstash/encrypt-query-language as well or the next sync will bring the
broken form back.
---
 packages/eql/tasks/test/docs_v3_grep.sh       |  24 +++-
 .../workflow-grep-q-pipelines.test.mjs        | 115 +++++++++++++++++-
 2 files changed, 134 insertions(+), 5 deletions(-)

diff --git a/packages/eql/tasks/test/docs_v3_grep.sh b/packages/eql/tasks/test/docs_v3_grep.sh
index fdd6ba0a0..14cc27c67 100755
--- a/packages/eql/tasks/test/docs_v3_grep.sh
+++ b/packages/eql/tasks/test/docs_v3_grep.sh
@@ -68,9 +68,27 @@ ste_vec_alias_count=$(grep -c '^CREATE FUNCTION eql_v3\.ste_vec_contains' src/v3
 if [ "$ste_vec_alias_count" -ne 2 ]; then
   echo "FAIL: expected both deprecated ste_vec_contains overloads in src/v3/json/functions.sql" >&2
   status=1
-elif tasks/docs/doxygen-filter.sh src/v3/json/functions.sql | grep -q 'ste_vec_contains'; then
-  echo "FAIL: deprecated ste_vec_contains aliases leaked through the Doxygen input filter" >&2
-  status=1
+else
+  # CAPTURE, THEN MATCH — never `doxygen-filter.sh ... | grep -q ...`. `grep -q`
+  # exits at the first match and closes the pipe; the filter's awk then takes
+  # SIGPIPE and exits 141, and `set -o pipefail` makes that the pipeline's
+  # status. So the LEAK path — the one this guard exists for — scored as "no
+  # match" and the FAIL branch never ran, while the clean path (grep reads to
+  # EOF, exits 1) reported correctly. A check that can only ever say OK.
+  #
+  # Measured at 141 against the real filter output on macOS. Linux's larger
+  # pipe buffer absorbed the ~16 KB and hid it, so this was a platform split
+  # rather than an obvious bug. Guarded repo-wide by
+  # scripts/__tests__/workflow-grep-q-pipelines.test.mjs.
+  #
+  # A separate assignment also means `set -e` aborts if the filter itself
+  # fails, instead of the old pipeline quietly scoring a crashed filter as a
+  # pass.
+  filtered_sql=$(tasks/docs/doxygen-filter.sh src/v3/json/functions.sql)
+  if grep -q 'ste_vec_contains' <<< "$filtered_sql"; then
+    echo "FAIL: deprecated ste_vec_contains aliases leaked through the Doxygen input filter" >&2
+    status=1
+  fi
 fi
 
 if [ "$status" -eq 0 ]; then
diff --git a/scripts/__tests__/workflow-grep-q-pipelines.test.mjs b/scripts/__tests__/workflow-grep-q-pipelines.test.mjs
index 7d0b3401b..5061dcf26 100644
--- a/scripts/__tests__/workflow-grep-q-pipelines.test.mjs
+++ b/scripts/__tests__/workflow-grep-q-pipelines.test.mjs
@@ -1,4 +1,5 @@
-import { readdirSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { readdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
 import { REPO_ROOT } from './lib/repo-root.mjs'
@@ -36,6 +37,20 @@ import { readWorkflow, workflowFiles } from './lib/workflows.mjs'
  *
  * `grep -q` reading a FILE or a here-string is fine and stays allowed — there
  * is no writer to signal. Only pipelines are rejected.
+ *
+ * The second `describe` below extends the same rule to tracked shell scripts,
+ * because the hazard is a property of the shell and not of GitHub Actions.
+ * `packages/eql/tasks/test/docs_v3_grep.sh` had it in the fail-OPEN direction:
+ *
+ *   elif tasks/docs/doxygen-filter.sh src/v3/json/functions.sql | grep -q 'ste_vec_contains'
+ *
+ * On the failure path — the deprecated aliases DO leak through the Doxygen
+ * filter — grep matched, exited 0, and closed the pipe; awk took SIGPIPE, the
+ * pipeline reported 141 under `set -o pipefail`, the `elif` was false, and the
+ * FAIL branch never ran. Only the clean case was reported correctly, so the
+ * guard could only ever say "OK". Measured at 141 against the real 16 KB filter
+ * output on macOS, whose pipe buffer starts at 16 KB; Linux's 64 KB buffer hid
+ * it, which is exactly the platform split the tar case above describes.
  */
 
 /** Composite actions are part of the same call tree, and run the same shells. */
@@ -72,6 +87,15 @@ function runBlocks(doc, file) {
  */
 const PIPED_QUIET_GREP = /\|\s*grep\s+(?:-[a-zA-Z]*q[a-zA-Z]*|--quiet)\b/
 
+/**
+ * Whole-line `#` comments are not code, and the rule has to survive being
+ * WRITTEN DOWN: the fix comment on `docs_v3_grep.sh` quotes the very pipeline
+ * it replaced, and without this the guard reported the explanation as the
+ * defect. Only leading-`#` lines are skipped — stripping `#` to end-of-line
+ * would eat it out of grep patterns and quoted strings.
+ */
+const isComment = (line) => /^\s*#/.test(line)
+
 describe('no run: block pipes into grep -q', () => {
   const files = [...workflowFiles(), ...actionManifests()]
 
@@ -85,7 +109,9 @@ describe('no run: block pipes into grep -q', () => {
         run
           .split('\n')
           .map((line, i) => ({ where, line: line.trim(), number: i + 1 }))
-          .filter(({ line }) => PIPED_QUIET_GREP.test(line)),
+          .filter(
+            ({ line }) => !isComment(line) && PIPED_QUIET_GREP.test(line),
+          ),
       )
       .map((hit) => `${file} › ${hit.where} › line ${hit.number}: ${hit.line}`),
   )
@@ -94,3 +120,88 @@ describe('no run: block pipes into grep -q', () => {
     expect(offenders).toEqual([])
   })
 })
+
+/**
+ * `echo` and `printf` writing a bounded diagnostic string — an error message, a
+ * captured comment block — are exempt: the whole write lands in the pipe buffer
+ * before grep can exit, so there is no blocked writer left to signal. The
+ * exemption is about SIZE, not about them being builtins (a builtin in a
+ * pipeline still runs in a subshell and still takes SIGPIPE), so `echo "$x"`
+ * where `$x` could grow past a pipe buffer would reintroduce the hazard. Every
+ * exempted call site in this tree pipes a short, known-bounded string.
+ */
+const BOUNDED_WRITERS = new Set(['echo', 'printf'])
+
+/** The first word of the command immediately upstream of the `| grep -q`. */
+function upstreamWriter(line) {
+  const match = line.match(PIPED_QUIET_GREP)
+  if (!match) return null
+  const feeding = line.slice(0, match.index).split('|').pop() ?? ''
+  let head = feeding.trim()
+  let previous
+  do {
+    previous = head
+    head = head
+      .replace(/^(?:!|if|elif|while|until|then|do|&&|\|\||;)\s*/, '')
+      .trim()
+  } while (head !== previous)
+  return head.split(/\s+/)[0] ?? ''
+}
+
+/** Tracked shell scripts, via git so it honours .gitignore. */
+function shellScripts() {
+  return execFileSync('git', ['ls-files', '-z', '--', '*.sh'], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+  })
+    .split('\0')
+    .filter(Boolean)
+}
+
+describe('no shell script pipes an unbounded writer into grep -q', () => {
+  const scripts = shellScripts()
+
+  it('finds shell scripts to check', () => {
+    expect(scripts.length).toBeGreaterThan(0)
+    expect(scripts).toContain('packages/eql/tasks/test/docs_v3_grep.sh')
+  })
+
+  it('parses the upstream writer out of a pipeline', () => {
+    // The classifier is what decides whether a line is reported, so a bug in it
+    // silently empties the check below.
+    expect(upstreamWriter('if ! echo "$b" | grep -q "@brief"; then')).toBe(
+      'echo',
+    )
+    expect(upstreamWriter("printf '%s' \"$err\" | grep -qi 'HTTP 404'")).toBe(
+      'printf',
+    )
+    expect(
+      upstreamWriter("elif tasks/docs/doxygen-filter.sh x.sql | grep -q 'y'"),
+    ).toBe('tasks/docs/doxygen-filter.sh')
+    expect(upstreamWriter('cat f | tr a b | grep -q x')).toBe('tr')
+    expect(upstreamWriter('grep -q x file')).toBeNull()
+    expect(isComment('  # never `foo.sh | grep -q bar`')).toBe(true)
+    expect(isComment('grep -q \'#tag\' <<< "$x"')).toBe(false)
+  })
+
+  const offenders = scripts.flatMap((file) =>
+    readFileSync(join(REPO_ROOT, file), 'utf8')
+      .split('\n')
+      .map((line, i) => ({ line: line.trim(), number: i + 1 }))
+      .filter(({ line }) => {
+        if (isComment(line)) return false
+        const writer = upstreamWriter(line)
+        return writer !== null && !BOUNDED_WRITERS.has(writer)
+      })
+      .map((hit) => `${file}:${hit.number}: ${hit.line}`),
+  )
+
+  it('has none', () => {
+    expect(
+      offenders,
+      'Capture the output first and match against the variable:\n' +
+        '  out=$(producer)\n' +
+        '  grep -q pattern <<< "$out"',
+    ).toEqual([])
+  })
+})

From 9cec92ee5a6f4aed60d67f46046a6697c190d7eb Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 13:57:43 +1000
Subject: [PATCH 19/20] docs: stop telling agents the release gate is currently
 blocking
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

AGENTS.md asserted a live verdict — "It fires today on the hand-applied
3.0.5 bump … and it blocks the Version Packages PR as well as the publish" —
which stopped being true the moment `@cipherstash/eql@3.0.5` reached npm.
This branch's own 2a140e84 re-emits against the published 3.0.5, and
`node scripts/release-gate.mjs` now exits 0 with "nothing to publish".

A durable agent instruction that says to expect a red gate is worse than no
instruction: it turns a real blocker into an expected one and the agent
stops looking. The plan doc carried the same claim in weaker form.

Both now state the CONDITION under which the gate fires and point at the
script for what it blocks at any given moment — that answer is computed from
the registry at run time and does not belong in a checked-in sentence.

`frozen-publisher-docs.test.mjs` guards both halves of the drift. No doc may
assert a live gate verdict; it went red on both files before this change.
And each doc documents the eql freeze if and only if `FROZEN_PUBLISHERS`
still carries it — keyed on the map rather than on a date, so the Phase-5
cutover cannot delete the entry without taking the prose with it. That is
the same drift in the other direction, and it is already scheduled.
---
 AGENTS.md                                     | 16 ++--
 .../2026-08-13-eql-monorepo-absorption.md     |  2 +-
 .../__tests__/frozen-publisher-docs.test.mjs  | 93 +++++++++++++++++++
 3 files changed, 104 insertions(+), 7 deletions(-)
 create mode 100644 scripts/__tests__/frozen-publisher-docs.test.mjs

diff --git a/AGENTS.md b/AGENTS.md
index 59923b409..33645256b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -321,12 +321,16 @@ monorepo, which is where the silent failures are.
   published from another repository, and the gate **exits non-zero** — failing
   the `gate` job, which skips `release` entirely — if such a package's committed
   version is missing from npm, or if any published package carries a runtime
-  `workspace:` range that only that package could satisfy. It fires today on the
-  hand-applied 3.0.5 bump, which a changeset-side guard could not see, and it
-  blocks the Version Packages PR as well as the publish. `tests.yml` runs the
-  same script at PR time so the answer arrives a merge earlier. Delete the
-  `@cipherstash/eql` entry in the Phase-5 cutover — and note the FFI half of
-  that map is what turns `lint-no-ffi-changeset.mjs`'s unstated assumption
+  `workspace:` range that only that package could satisfy. Either condition
+  stops the Version Packages PR and the publish alike. A changeset-side guard
+  sees neither — which is why the hand-applied 3.0.5 bump needed this one.
+  **Whether the gate is blocking anything right now is a question for the
+  registry, not for this file: run `node scripts/release-gate.mjs` and read what
+  it says.** `tests.yml` runs the same script at PR time so the answer arrives a
+  merge earlier. Delete the `@cipherstash/eql` entry in the Phase-5 cutover —
+  `scripts/__tests__/frozen-publisher-docs.test.mjs` fails until this paragraph
+  goes with it — and note the FFI half of that map is what turns
+  `lint-no-ffi-changeset.mjs`'s unstated assumption
   ("all seven are already on npm at the workspace version") into a checked one.
   Note too that 3.0.5 did *not* come from `changeset version` —
   eleven unrelated changesets were pending, so the bump was entered by hand in
diff --git a/docs/plans/2026-08-13-eql-monorepo-absorption.md b/docs/plans/2026-08-13-eql-monorepo-absorption.md
index 4e87c4735..714e287a4 100644
--- a/docs/plans/2026-08-13-eql-monorepo-absorption.md
+++ b/docs/plans/2026-08-13-eql-monorepo-absorption.md
@@ -315,7 +315,7 @@ Five surfaces, each flipped independently, each inert until its own cutover.
 
 - [ ] **Carried over from Phase 4, deliberately.** Port `lint-release.yml` and the two reusable workflows (`_build-sql.yml`, `_build-docs.yml`) alongside the release workflows they gate and are called from — a lint aimed at four absent files is worse than no lint. Add `cache: false` to the three `jdx/mise-action` steps that omit it (`_build-sql.yml`, `_build-docs.yml`, `release-postgres-eql-image.yml`), and add those two plus `release-plz.yml` to `scripts/lint-no-workflow-caching.mjs`'s `TARGETS`, with their remote actions in `AUDITED_ACTIONS` — or the gate fails on the addition itself.
 - [ ] **Then delete `packages/eql/.github/` entirely**, and convert the shrinking allowlist in `scripts/__tests__/eql-suite-ci.test.mjs` to a straight `existsSync(...) === false`, alongside the existing protect-ffi assertion in `lintWiring.test.ts`. The allowlist is an equality, so it will already be failing by the time the last file goes — that is what makes this step forced rather than remembered.
-- [x] ~~Add `scripts/lint-no-eql-changeset.mjs` in the shape of the FFI guard~~ — **superseded, and do not restore the parked changeset.** The guard landed instead as `FROZEN_PUBLISHERS` in `scripts/release-gate.mjs`, which is strictly stronger: it exits non-zero on any frozen package whose committed version is missing from npm *and* on any runtime `workspace:` range only that package could satisfy, so it catches the hand-applied 3.0.5 bump that no changeset-side guard could see. It runs at PR time via `tests.yml` and at release time via `release.yml`. `.changeset/rename-ste-vec-contains.md.deferred` was deleted deliberately in `9b1c44d9` — the 3.0.5 bump was entered by hand in the CHANGELOG, so re-parking that `major` changeset would make the cutover bump the package a second time (3.0.5 → 4.0.0) for a rename already released. **Phase-5 action: delete the `@cipherstash/eql` entry from `FROZEN_PUBLISHERS`, nothing more.**
+- [x] ~~Add `scripts/lint-no-eql-changeset.mjs` in the shape of the FFI guard~~ — **superseded, and do not restore the parked changeset.** The guard landed instead as `FROZEN_PUBLISHERS` in `scripts/release-gate.mjs`, which is strictly stronger: it exits non-zero on any frozen package whose committed version is missing from npm *and* on any runtime `workspace:` range only that package could satisfy, a pair of conditions no changeset-side guard can see — which is why the hand-applied 3.0.5 bump needed this guard rather than that one. (Run `node scripts/release-gate.mjs` for what it blocks at any given moment; that answer comes from the registry and is not recorded here.) It runs at PR time via `tests.yml` and at release time via `release.yml`. `.changeset/rename-ste-vec-contains.md.deferred` was deleted deliberately in `9b1c44d9` — the 3.0.5 bump was entered by hand in the CHANGELOG, so re-parking that `major` changeset would make the cutover bump the package a second time (3.0.5 → 4.0.0) for a rename already released. **Phase-5 action: delete the `@cipherstash/eql` entry from `FROZEN_PUBLISHERS`, nothing more.**
 - [ ] Repoint all EQL manifests at `cipherstash/stack`: `packages/eql/packages/eql/package.json` — `repository.url`, `repository.directory` → `packages/eql/packages/eql`, **and `bugs.url`** (line 13, still `encrypt-query-language/issues`, which would send users to an archived repo) — plus `crates/eql-bindings/Cargo.toml` (`repository`, `homepage`) and `release-plz.toml`'s prose. npm and crates.io both reject a publish whose repository field does not match; `bugs.url` is not enforced, which is why it is the one that survives a cutover unnoticed.
 - [ ] Port `release.yml`'s EQL half into this repo's `release.yml` — the existing gate-then-publish structure already models "one version authority plus N idempotent publishers", which is the shape it was derived from. Preserve the `classify` prerelease path and the `eql-typescript-v<version>` idempotency short-circuit.
 - [ ] Port `release-plz.yml` unchanged in filename — crates.io trusted publishing binds to it.
diff --git a/scripts/__tests__/frozen-publisher-docs.test.mjs b/scripts/__tests__/frozen-publisher-docs.test.mjs
new file mode 100644
index 000000000..843d73959
--- /dev/null
+++ b/scripts/__tests__/frozen-publisher-docs.test.mjs
@@ -0,0 +1,93 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { FROZEN_PUBLISHERS } from '../release-gate.mjs'
+import { REPO_ROOT } from './lib/repo-root.mjs'
+
+/**
+ * `FROZEN_PUBLISHERS` is described in prose in two places, and the prose is
+ * what an agent reads before it decides whether a red `release:gate` is news.
+ *
+ * Both halves of that had already drifted.
+ *
+ * AGENTS.md asserted a LIVE VERDICT — "It fires today on the hand-applied 3.0.5
+ * bump … and it blocks the Version Packages PR as well as the publish" — which
+ * stopped being true the moment `@cipherstash/eql@3.0.5` reached npm. The gate
+ * now exits 0 ("nothing to publish"). A durable instruction that tells an agent
+ * to expect a red gate is worse than no instruction: it turns a real blocker
+ * into an expected one, and the agent stops looking.
+ *
+ * That is the class this guard covers. A gate verdict is computed from the
+ * registry at run time, so it belongs in the gate's output, not in a checked-in
+ * sentence — the docs should state the CONDITION under which it fires and point
+ * at `node scripts/release-gate.mjs` for the answer.
+ *
+ * The second half is the deletion that is already scheduled. Phase 5 removes
+ * the `@cipherstash/eql` entry from the map, and on that day both documents
+ * become wrong in the other direction — still instructing agents about a freeze
+ * that no longer exists. Keyed on the map rather than on a date, so the cutover
+ * PR cannot land the code change without the prose.
+ */
+
+const EQL = '@cipherstash/eql'
+
+/** Where the freeze is explained, and the instruction each file carries. */
+const DOCS = [
+  {
+    file: 'AGENTS.md',
+    // Both spellings resolve to "the `@cipherstash/eql` entry", which is the
+    // thing Phase 5 deletes — matching that keeps the guard anchored to the
+    // instruction rather than to a paragraph that may be rewritten.
+    instruction: /`@cipherstash\/eql` entry/,
+  },
+  {
+    file: 'docs/plans/2026-08-13-eql-monorepo-absorption.md',
+    instruction: /`@cipherstash\/eql` entry/,
+  },
+]
+
+/**
+ * Present-tense assertions that the gate is CURRENTLY blocking. Not a style
+ * rule — each of these was true when written and false by the next merge, and
+ * neither has any way to notice.
+ */
+const LIVE_VERDICT_CLAIMS = [
+  /\bfires today\b/,
+  /\bblocks the Version Packages PR\b/,
+  /\bcatches the hand-applied 3\.0\.5 bump\b/,
+]
+
+const read = (file) => readFileSync(join(REPO_ROOT, file), 'utf8')
+
+describe('frozen-publisher docs track the map', () => {
+  it('still has a frozen entry to document', () => {
+    // The map going empty is the Phase-5 end state and a legitimate one — but
+    // it must arrive with the doc edits below, not ahead of them. An empty map
+    // here means every `iff` assertion is vacuous, so say so out loud.
+    expect(FROZEN_PUBLISHERS.size).toBeGreaterThan(0)
+  })
+
+  it.each(DOCS)('$file documents the eql freeze iff the map carries it', ({
+    file,
+    instruction,
+  }) => {
+    expect(
+      instruction.test(read(file)),
+      FROZEN_PUBLISHERS.has(EQL)
+        ? `${file} no longer tells an agent about the ${EQL} freeze, but ` +
+            'FROZEN_PUBLISHERS still carries it.'
+        : `${EQL} has left FROZEN_PUBLISHERS (Phase-5 cutover), so ${file} ` +
+            'must stop instructing agents about the freeze.',
+    ).toBe(FROZEN_PUBLISHERS.has(EQL))
+  })
+
+  it.each(DOCS)('$file asserts no live gate verdict', ({ file }) => {
+    const body = read(file)
+    expect(
+      LIVE_VERDICT_CLAIMS.filter((claim) => claim.test(body)).map(String),
+      `${file} states what release-gate currently does. That is decided by the ` +
+        'registry at run time — describe the condition and point at ' +
+        '`node scripts/release-gate.mjs` instead.',
+    ).toEqual([])
+  })
+})

From 00d685f1451af4be0da2d8b80048e98266c98354 Mon Sep 17 00:00:00 2001
From: Toby Hede <toby@cipherstash.com>
Date: Wed, 19 Aug 2026 13:57:55 +1000
Subject: [PATCH 20/20] fix(skills): stash-prisma never carried the
 post-upgrade re-plan
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The 1.0.0 -> 3.0.5 upgrade workflow landed in `packages/stack-prisma`'s
README and in a changeset, but not in the skill. `skills/` ships inside the
`stash` tarball and `installSkills()` copies it into the user's
`.claude/skills/`, so the README is what a human reads after hitting the
error and the skill is what an AGENT reads before causing it — and an agent
driving `db init` in a repo upgraded from 1.0.0 met

    Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data"
    which is not allowed by policy.

with no route out of it. The skill's install section still showed only the
first-time `contract emit` -> `migration plan` -> `migrate` sequence and
said nothing about upgrades, or about `migration plan` being the only
command that vendors new migration packages.

`stale-vendored-space.test.ts` already pinned the README to the planner's
real refusal string, on the reasoning that the message cannot be improved
from inside the package so the shipped docs have to bridge it to the remedy.
That reasoning covers the skill identically, so the assertion is extended to
both files rather than duplicated as a naked content check — the pair now
cannot drift from the message the planner actually emits. It went red on the
skill alone.

Adds the `stash` patch changeset a skills change requires, and widens the
skill's frontmatter trigger to the upgrade path.
---
 .changeset/prisma-skill-upgrade-replan.md     | 16 +++++++
 .../test/v3/stale-vendored-space.test.ts      | 48 +++++++++++++++----
 skills/stash-prisma/SKILL.md                  | 41 +++++++++++++++-
 3 files changed, 94 insertions(+), 11 deletions(-)
 create mode 100644 .changeset/prisma-skill-upgrade-replan.md

diff --git a/.changeset/prisma-skill-upgrade-replan.md b/.changeset/prisma-skill-upgrade-replan.md
new file mode 100644
index 000000000..19d93f919
--- /dev/null
+++ b/.changeset/prisma-skill-upgrade-replan.md
@@ -0,0 +1,16 @@
+---
+'stash': patch
+---
+
+`skills/stash-prisma` now documents the re-plan step that follows an
+`@cipherstash/stack-prisma` upgrade: `rm -rf migrations/cipherstash && npx
+prisma-next migration plan`, why only `migration plan` vendors new migration
+packages, and the exact `db init` refusal a stale vendored directory produces on
+a fresh database (`Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class
+"data" which is not allowed by policy.`).
+
+The package README already carried this; the skill did not — and the skill is
+what ships inside the `stash` tarball and gets copied into a user's
+`.claude/skills/`, so an agent driving the upgrade hit the refusal with no route
+out of it. `packages/stack-prisma/test/v3/stale-vendored-space.test.ts` now pins
+both files to the planner's real message so they cannot drift apart again.
diff --git a/packages/stack-prisma/test/v3/stale-vendored-space.test.ts b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
index 00b761546..3243c3b58 100644
--- a/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
+++ b/packages/stack-prisma/test/v3/stale-vendored-space.test.ts
@@ -512,17 +512,45 @@ describe('fresh database: both install paths must converge on eql-3.0.5', () =>
     expect(message).not.toContain('migration plan')
 
     // Since the message cannot be improved from inside this package, the
-    // README — which ships in the npm tarball — has to carry the bridge
-    // from that exact string to the remedy. Pinned so the two cannot
-    // drift apart: a user's only route from the error to the fix is
-    // pasting it into a search.
-    const readme = await readFile(
-      join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'README.md'),
-      'utf8',
+    // SHIPPED DOCS have to carry the bridge from that exact string to the
+    // remedy. Pinned so they cannot drift apart: a user's only route from the
+    // error to the fix is pasting it into a search.
+    //
+    // BOTH of them, and the skill is the one that was missed. The README ships
+    // in the npm tarball and is read by a human who hit the error. `skills/`
+    // ships inside the `stash` tarball and `installSkills()` copies it into the
+    // user's `.claude/skills/` — so it is what an AGENT reads, and an agent
+    // driving `db init` in a repo upgraded from 1.0.0 hits this refusal with no
+    // route out of it. Nothing type-checks either file; this assertion is the
+    // only thing holding the pair to the planner's real message.
+    // `test/v3` -> `test` -> `packages/stack-prisma` -> `packages` -> root.
+    const repoRoot = join(
+      dirname(fileURLToPath(import.meta.url)),
+      '..',
+      '..',
+      '..',
+      '..',
     )
-    expect(readme).toContain(message)
-    expect(readme).toContain('rm -rf migrations/cipherstash')
-    expect(readme).toContain('prisma-next migration plan')
+    const shipped = {
+      'packages/stack-prisma/README.md': await readFile(
+        join(repoRoot, 'packages/stack-prisma/README.md'),
+        'utf8',
+      ),
+      'skills/stash-prisma/SKILL.md': await readFile(
+        join(repoRoot, 'skills/stash-prisma/SKILL.md'),
+        'utf8',
+      ),
+    }
+    for (const [file, body] of Object.entries(shipped)) {
+      expect(body, `${file} does not name the refusal`).toContain(message)
+      expect(body, `${file} does not carry the remedy`).toContain(
+        'rm -rf migrations/cipherstash',
+      )
+      expect(
+        body,
+        `${file} does not name the command that vendors it`,
+      ).toContain('prisma-next migration plan')
+    }
   })
 
   it('the same fresh `db init` succeeds once the instruction is followed', async () => {
diff --git a/skills/stash-prisma/SKILL.md b/skills/stash-prisma/SKILL.md
index 2f6072e49..4662bc3cd 100644
--- a/skills/stash-prisma/SKILL.md
+++ b/skills/stash-prisma/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: stash-prisma
-description: Integrate CipherStash searchable field-level encryption with Prisma Next using @cipherstash/stack-prisma (EQL v3). Covers the full 31-constructor catalog of domain-named encrypted column types in schema.prisma (per plaintext type × capability tier — Text/TextEq/TextOrd/TextMatch/TextSearch, Integer/Smallint/BigInt/Numeric/Real/Double × Eq/Ord, Date/Timestamp × Eq/Ord, Boolean, Json), the one-call cipherstashFromStack 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, eqlJsonPathAsc/eqlJsonPathDesc), EQL bundle installation via prisma-next migrate, and authentication. Use when adding encryption to a Prisma Next project, choosing a column type, or querying encrypted columns.
+description: Integrate CipherStash searchable field-level encryption with Prisma Next using @cipherstash/stack-prisma (EQL v3). Covers the full 31-constructor catalog of domain-named encrypted column types in schema.prisma (per plaintext type × capability tier — Text/TextEq/TextOrd/TextMatch/TextSearch, Integer/Smallint/BigInt/Numeric/Real/Double × Eq/Ord, Date/Timestamp × Eq/Ord, Boolean, Json), the one-call cipherstashFromStack 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, eqlJsonPathAsc/eqlJsonPathDesc), EQL bundle installation via prisma-next migrate, and authentication. Use when adding encryption to a Prisma Next project, upgrading @cipherstash/stack-prisma, choosing a column type, or querying encrypted columns.
 ---
 
 # CipherStash Stack — Prisma Next Integration
@@ -169,6 +169,41 @@ 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
 migrate`) unless you pass `--force`.
 
+### After upgrading `@cipherstash/stack-prisma`, re-plan before anything else
+
+Only `prisma-next migration plan` copies migration packages into your repo, and
+the seed phase never rewrites a directory that already exists. A
+`migrations/cipherstash/` generated against an older version therefore keeps that
+version's EQL bundle forever — it is old, not corrupt, so it passes every
+integrity check and nothing reports a problem.
+
+**After upgrading the package, delete the vendored directory and regenerate it:**
+
+```bash
+rm -rf migrations/cipherstash
+npx prisma-next migration plan
+```
+
+The database is untouched by this: markers are keyed by invariant, so
+already-applied invariants do not re-run and the only new work is the upgrade
+edge.
+
+Skipping it is not always fatal, which is what makes it easy to miss. 1.0.0
+shipped the baseline at **eql-3.0.4**; later versions bake **eql-3.0.5** into the
+same baseline directory (`20260601T0100_install_eql_v3_bundle`), so its bytes and
+its `migrationHash` changed:
+
+| You run | With a stale `migrations/cipherstash/` |
+| --- | --- |
+| `prisma-next migration plan` | Succeeds, silently keeping the stale baseline — no hash mismatch, because it is intact, just old. |
+| `prisma-next migrate` (existing database) | Correct: applies the 3.0.5 upgrade edge only. |
+| `prisma-next migrate` (fresh database) | Correct end state, but installs eql-3.0.4 and then immediately re-installs eql-3.0.5 over it. |
+| `prisma-next db init` (fresh database) | **Fails**: `Operation cipherstash.upgrade-eql-v3-bundle-3.0.5 has class "data" which is not allowed by policy.` `db init` is additive-only and the stale baseline does not carry the 3.0.5 invariant, so the planner has to reach for the data-classed upgrade edge. The message does not say any of that — the remedy is the `rm -rf` above. |
+
+Upgrading and then running `migrate` or `db init` **without** planning first
+leaves the newer bundle off disk entirely, so it is silently skipped and the
+database stays on the older one.
+
 ## Encrypting data that already exists (`stash encrypt`)
 
 Declaring an encrypted column only covers new writes. To encrypt rows already in
@@ -373,4 +408,8 @@ Run Prisma Next apps on a Node runtime where the native module loads.
   `DoubleOrd` column ↔ `EncryptedNumber.from(...)` value.
 - **Regenerate the contract** (`prisma-next contract emit`) after changing a
   column's encrypted type, so `cipherstashFromStack` and the migrations agree.
+- **Re-plan after upgrading `@cipherstash/stack-prisma`** — `rm -rf
+  migrations/cipherstash && npx prisma-next migration plan`. Only `migration
+  plan` vendors new migration packages; skip it and a fresh `db init` fails with
+  `... has class "data" which is not allowed by policy.`
 - **Never log or read `~/.cipherstash`** or `.env*` credential files (see `stash-cli`).